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 33 /** 34 * struct drm_crtc_commit - track modeset commits on a CRTC 35 * 36 * This structure is used to track pending modeset changes and atomic commit on 37 * a per-CRTC basis. Since updating the list should never block this structure 38 * is reference counted to allow waiters to safely wait on an event to complete, 39 * without holding any locks. 40 * 41 * It has 3 different events in total to allow a fine-grained synchronization 42 * between outstanding updates:: 43 * 44 * atomic commit thread hardware 45 * 46 * write new state into hardware ----> ... 47 * signal hw_done 48 * switch to new state on next 49 * ... v/hblank 50 * 51 * wait for buffers to show up ... 52 * 53 * ... send completion irq 54 * irq handler signals flip_done 55 * cleanup old buffers 56 * 57 * signal cleanup_done 58 * 59 * wait for flip_done <---- 60 * clean up atomic state 61 * 62 * The important bit to know is that cleanup_done is the terminal event, but the 63 * ordering between flip_done and hw_done is entirely up to the specific driver 64 * and modeset state change. 65 * 66 * For an implementation of how to use this look at 67 * drm_atomic_helper_setup_commit() from the atomic helper library. 68 */ 69 struct drm_crtc_commit { 70 /** 71 * @crtc: 72 * 73 * DRM CRTC for this commit. 74 */ 75 struct drm_crtc *crtc; 76 77 /** 78 * @ref: 79 * 80 * Reference count for this structure. Needed to allow blocking on 81 * completions without the risk of the completion disappearing 82 * meanwhile. 83 */ 84 struct kref ref; 85 86 /** 87 * @flip_done: 88 * 89 * Will be signaled when the hardware has flipped to the new set of 90 * buffers. Signals at the same time as when the drm event for this 91 * commit is sent to userspace, or when an out-fence is singalled. Note 92 * that for most hardware, in most cases this happens after @hw_done is 93 * signalled. 94 */ 95 struct completion flip_done; 96 97 /** 98 * @hw_done: 99 * 100 * Will be signalled when all hw register changes for this commit have 101 * been written out. Especially when disabling a pipe this can be much 102 * later than than @flip_done, since that can signal already when the 103 * screen goes black, whereas to fully shut down a pipe more register 104 * I/O is required. 105 * 106 * Note that this does not need to include separately reference-counted 107 * resources like backing storage buffer pinning, or runtime pm 108 * management. 109 */ 110 struct completion hw_done; 111 112 /** 113 * @cleanup_done: 114 * 115 * Will be signalled after old buffers have been cleaned up by calling 116 * drm_atomic_helper_cleanup_planes(). Since this can only happen after 117 * a vblank wait completed it might be a bit later. This completion is 118 * useful to throttle updates and avoid hardware updates getting ahead 119 * of the buffer cleanup too much. 120 */ 121 struct completion cleanup_done; 122 123 /** 124 * @commit_entry: 125 * 126 * Entry on the per-CRTC commit_list. Protected by crtc->commit_lock. 127 */ 128 struct list_head commit_entry; 129 130 /** 131 * @event: 132 * 133 * &drm_pending_vblank_event pointer to clean up private events. 134 */ 135 struct drm_pending_vblank_event *event; 136 }; 137 138 struct __drm_planes_state { 139 struct drm_plane *ptr; 140 struct drm_plane_state *state; 141 }; 142 143 struct __drm_crtcs_state { 144 struct drm_crtc *ptr; 145 struct drm_crtc_state *state; 146 struct drm_crtc_commit *commit; 147 }; 148 149 struct __drm_connnectors_state { 150 struct drm_connector *ptr; 151 struct drm_connector_state *state; 152 }; 153 154 /** 155 * struct drm_atomic_state - the global state object for atomic updates 156 * @ref: count of all references to this state (will not be freed until zero) 157 * @dev: parent DRM device 158 * @allow_modeset: allow full modeset 159 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics 160 * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL. 161 * @planes: pointer to array of structures with per-plane data 162 * @crtcs: pointer to array of CRTC pointers 163 * @num_connector: size of the @connectors and @connector_states arrays 164 * @connectors: pointer to array of structures with per-connector data 165 * @acquire_ctx: acquire context for this atomic modeset state update 166 */ 167 struct drm_atomic_state { 168 struct kref ref; 169 170 struct drm_device *dev; 171 bool allow_modeset : 1; 172 bool legacy_cursor_update : 1; 173 bool legacy_set_config : 1; 174 struct __drm_planes_state *planes; 175 struct __drm_crtcs_state *crtcs; 176 int num_connector; 177 struct __drm_connnectors_state *connectors; 178 179 struct drm_modeset_acquire_ctx *acquire_ctx; 180 181 /** 182 * @commit_work: 183 * 184 * Work item which can be used by the driver or helpers to execute the 185 * commit without blocking. 186 */ 187 struct work_struct commit_work; 188 }; 189 190 void drm_crtc_commit_put(struct drm_crtc_commit *commit); 191 static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit) 192 { 193 kref_get(&commit->ref); 194 } 195 196 struct drm_atomic_state * __must_check 197 drm_atomic_state_alloc(struct drm_device *dev); 198 void drm_atomic_state_clear(struct drm_atomic_state *state); 199 200 /** 201 * drm_atomic_state_get - acquire a reference to the atomic state 202 * @state: The atomic state 203 * 204 * Returns a new reference to the @state 205 */ 206 static inline struct drm_atomic_state * 207 drm_atomic_state_get(struct drm_atomic_state *state) 208 { 209 kref_get(&state->ref); 210 return state; 211 } 212 213 void __drm_atomic_state_free(struct kref *ref); 214 215 /** 216 * drm_atomic_state_put - release a reference to the atomic state 217 * @state: The atomic state 218 * 219 * This releases a reference to @state which is freed after removing the 220 * final reference. No locking required and callable from any context. 221 */ 222 static inline void drm_atomic_state_put(struct drm_atomic_state *state) 223 { 224 kref_put(&state->ref, __drm_atomic_state_free); 225 } 226 227 int __must_check 228 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state); 229 void drm_atomic_state_default_clear(struct drm_atomic_state *state); 230 void drm_atomic_state_default_release(struct drm_atomic_state *state); 231 232 struct drm_crtc_state * __must_check 233 drm_atomic_get_crtc_state(struct drm_atomic_state *state, 234 struct drm_crtc *crtc); 235 int drm_atomic_crtc_set_property(struct drm_crtc *crtc, 236 struct drm_crtc_state *state, struct drm_property *property, 237 uint64_t val); 238 struct drm_plane_state * __must_check 239 drm_atomic_get_plane_state(struct drm_atomic_state *state, 240 struct drm_plane *plane); 241 int drm_atomic_plane_set_property(struct drm_plane *plane, 242 struct drm_plane_state *state, struct drm_property *property, 243 uint64_t val); 244 struct drm_connector_state * __must_check 245 drm_atomic_get_connector_state(struct drm_atomic_state *state, 246 struct drm_connector *connector); 247 int drm_atomic_connector_set_property(struct drm_connector *connector, 248 struct drm_connector_state *state, struct drm_property *property, 249 uint64_t val); 250 251 /** 252 * drm_atomic_get_existing_crtc_state - get crtc state, if it exists 253 * @state: global atomic state object 254 * @crtc: crtc to grab 255 * 256 * This function returns the crtc state for the given crtc, or NULL 257 * if the crtc is not part of the global atomic state. 258 */ 259 static inline struct drm_crtc_state * 260 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state, 261 struct drm_crtc *crtc) 262 { 263 return state->crtcs[drm_crtc_index(crtc)].state; 264 } 265 266 /** 267 * drm_atomic_get_existing_plane_state - get plane state, if it exists 268 * @state: global atomic state object 269 * @plane: plane to grab 270 * 271 * This function returns the plane state for the given plane, or NULL 272 * if the plane is not part of the global atomic state. 273 */ 274 static inline struct drm_plane_state * 275 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state, 276 struct drm_plane *plane) 277 { 278 return state->planes[drm_plane_index(plane)].state; 279 } 280 281 /** 282 * drm_atomic_get_existing_connector_state - get connector state, if it exists 283 * @state: global atomic state object 284 * @connector: connector to grab 285 * 286 * This function returns the connector state for the given connector, 287 * or NULL if the connector is not part of the global atomic state. 288 */ 289 static inline struct drm_connector_state * 290 drm_atomic_get_existing_connector_state(struct drm_atomic_state *state, 291 struct drm_connector *connector) 292 { 293 int index = drm_connector_index(connector); 294 295 if (index >= state->num_connector) 296 return NULL; 297 298 return state->connectors[index].state; 299 } 300 301 /** 302 * __drm_atomic_get_current_plane_state - get current plane state 303 * @state: global atomic state object 304 * @plane: plane to grab 305 * 306 * This function returns the plane state for the given plane, either from 307 * @state, or if the plane isn't part of the atomic state update, from @plane. 308 * This is useful in atomic check callbacks, when drivers need to peek at, but 309 * not change, state of other planes, since it avoids threading an error code 310 * back up the call chain. 311 * 312 * WARNING: 313 * 314 * Note that this function is in general unsafe since it doesn't check for the 315 * required locking for access state structures. Drivers must ensure that it is 316 * safe to access the returned state structure through other means. One common 317 * example is when planes are fixed to a single CRTC, and the driver knows that 318 * the CRTC lock is held already. In that case holding the CRTC lock gives a 319 * read-lock on all planes connected to that CRTC. But if planes can be 320 * reassigned things get more tricky. In that case it's better to use 321 * drm_atomic_get_plane_state and wire up full error handling. 322 * 323 * Returns: 324 * 325 * Read-only pointer to the current plane state. 326 */ 327 static inline const struct drm_plane_state * 328 __drm_atomic_get_current_plane_state(struct drm_atomic_state *state, 329 struct drm_plane *plane) 330 { 331 if (state->planes[drm_plane_index(plane)].state) 332 return state->planes[drm_plane_index(plane)].state; 333 334 return plane->state; 335 } 336 337 int __must_check 338 drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state, 339 struct drm_display_mode *mode); 340 int __must_check 341 drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, 342 struct drm_property_blob *blob); 343 int __must_check 344 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state, 345 struct drm_crtc *crtc); 346 void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, 347 struct drm_framebuffer *fb); 348 int __must_check 349 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, 350 struct drm_crtc *crtc); 351 int __must_check 352 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 353 struct drm_crtc *crtc); 354 int __must_check 355 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 356 struct drm_crtc *crtc); 357 358 void drm_atomic_legacy_backoff(struct drm_atomic_state *state); 359 360 void 361 drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret); 362 363 int __must_check drm_atomic_check_only(struct drm_atomic_state *state); 364 int __must_check drm_atomic_commit(struct drm_atomic_state *state); 365 int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); 366 367 #define for_each_connector_in_state(__state, connector, connector_state, __i) \ 368 for ((__i) = 0; \ 369 (__i) < (__state)->num_connector && \ 370 ((connector) = (__state)->connectors[__i].ptr, \ 371 (connector_state) = (__state)->connectors[__i].state, 1); \ 372 (__i)++) \ 373 for_each_if (connector) 374 375 #define for_each_crtc_in_state(__state, crtc, crtc_state, __i) \ 376 for ((__i) = 0; \ 377 (__i) < (__state)->dev->mode_config.num_crtc && \ 378 ((crtc) = (__state)->crtcs[__i].ptr, \ 379 (crtc_state) = (__state)->crtcs[__i].state, 1); \ 380 (__i)++) \ 381 for_each_if (crtc_state) 382 383 #define for_each_plane_in_state(__state, plane, plane_state, __i) \ 384 for ((__i) = 0; \ 385 (__i) < (__state)->dev->mode_config.num_total_plane && \ 386 ((plane) = (__state)->planes[__i].ptr, \ 387 (plane_state) = (__state)->planes[__i].state, 1); \ 388 (__i)++) \ 389 for_each_if (plane_state) 390 391 /** 392 * drm_atomic_crtc_needs_modeset - compute combined modeset need 393 * @state: &drm_crtc_state for the CRTC 394 * 395 * To give drivers flexibility struct &drm_crtc_state has 3 booleans to track 396 * whether the state CRTC changed enough to need a full modeset cycle: 397 * connectors_changed, mode_changed and active_changed. This helper simply 398 * combines these three to compute the overall need for a modeset for @state. 399 * 400 * The atomic helper code sets these booleans, but drivers can and should 401 * change them appropriately to accurately represent whether a modeset is 402 * really needed. In general, drivers should avoid full modesets whenever 403 * possible. 404 * 405 * For example if the CRTC mode has changed, and the hardware is able to enact 406 * the requested mode change without going through a full modeset, the driver 407 * should clear mode_changed during its ->atomic_check. 408 */ 409 static inline bool 410 drm_atomic_crtc_needs_modeset(struct drm_crtc_state *state) 411 { 412 return state->mode_changed || state->active_changed || 413 state->connectors_changed; 414 } 415 416 417 #endif /* DRM_ATOMIC_H_ */ 418