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 s64 __user *out_fence_ptr; 148 unsigned last_vblank_count; 149 }; 150 151 struct __drm_connnectors_state { 152 struct drm_connector *ptr; 153 struct drm_connector_state *state; 154 }; 155 156 /** 157 * struct drm_atomic_state - the global state object for atomic updates 158 * @ref: count of all references to this state (will not be freed until zero) 159 * @dev: parent DRM device 160 * @allow_modeset: allow full modeset 161 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics 162 * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL. 163 * @planes: pointer to array of structures with per-plane data 164 * @crtcs: pointer to array of CRTC pointers 165 * @num_connector: size of the @connectors and @connector_states arrays 166 * @connectors: pointer to array of structures with per-connector data 167 * @acquire_ctx: acquire context for this atomic modeset state update 168 */ 169 struct drm_atomic_state { 170 struct kref ref; 171 172 struct drm_device *dev; 173 bool allow_modeset : 1; 174 bool legacy_cursor_update : 1; 175 bool legacy_set_config : 1; 176 struct __drm_planes_state *planes; 177 struct __drm_crtcs_state *crtcs; 178 int num_connector; 179 struct __drm_connnectors_state *connectors; 180 181 struct drm_modeset_acquire_ctx *acquire_ctx; 182 183 /** 184 * @commit_work: 185 * 186 * Work item which can be used by the driver or helpers to execute the 187 * commit without blocking. 188 */ 189 struct work_struct commit_work; 190 }; 191 192 void drm_crtc_commit_put(struct drm_crtc_commit *commit); 193 static inline void drm_crtc_commit_get(struct drm_crtc_commit *commit) 194 { 195 kref_get(&commit->ref); 196 } 197 198 struct drm_atomic_state * __must_check 199 drm_atomic_state_alloc(struct drm_device *dev); 200 void drm_atomic_state_clear(struct drm_atomic_state *state); 201 202 /** 203 * drm_atomic_state_get - acquire a reference to the atomic state 204 * @state: The atomic state 205 * 206 * Returns a new reference to the @state 207 */ 208 static inline struct drm_atomic_state * 209 drm_atomic_state_get(struct drm_atomic_state *state) 210 { 211 kref_get(&state->ref); 212 return state; 213 } 214 215 void __drm_atomic_state_free(struct kref *ref); 216 217 /** 218 * drm_atomic_state_put - release a reference to the atomic state 219 * @state: The atomic state 220 * 221 * This releases a reference to @state which is freed after removing the 222 * final reference. No locking required and callable from any context. 223 */ 224 static inline void drm_atomic_state_put(struct drm_atomic_state *state) 225 { 226 kref_put(&state->ref, __drm_atomic_state_free); 227 } 228 229 int __must_check 230 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state); 231 void drm_atomic_state_default_clear(struct drm_atomic_state *state); 232 void drm_atomic_state_default_release(struct drm_atomic_state *state); 233 234 struct drm_crtc_state * __must_check 235 drm_atomic_get_crtc_state(struct drm_atomic_state *state, 236 struct drm_crtc *crtc); 237 int drm_atomic_crtc_set_property(struct drm_crtc *crtc, 238 struct drm_crtc_state *state, struct drm_property *property, 239 uint64_t val); 240 struct drm_plane_state * __must_check 241 drm_atomic_get_plane_state(struct drm_atomic_state *state, 242 struct drm_plane *plane); 243 int drm_atomic_plane_set_property(struct drm_plane *plane, 244 struct drm_plane_state *state, struct drm_property *property, 245 uint64_t val); 246 struct drm_connector_state * __must_check 247 drm_atomic_get_connector_state(struct drm_atomic_state *state, 248 struct drm_connector *connector); 249 int drm_atomic_connector_set_property(struct drm_connector *connector, 250 struct drm_connector_state *state, struct drm_property *property, 251 uint64_t val); 252 253 /** 254 * drm_atomic_get_existing_crtc_state - get crtc state, if it exists 255 * @state: global atomic state object 256 * @crtc: crtc to grab 257 * 258 * This function returns the crtc state for the given crtc, or NULL 259 * if the crtc is not part of the global atomic state. 260 */ 261 static inline struct drm_crtc_state * 262 drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state, 263 struct drm_crtc *crtc) 264 { 265 return state->crtcs[drm_crtc_index(crtc)].state; 266 } 267 268 /** 269 * drm_atomic_get_existing_plane_state - get plane state, if it exists 270 * @state: global atomic state object 271 * @plane: plane to grab 272 * 273 * This function returns the plane state for the given plane, or NULL 274 * if the plane is not part of the global atomic state. 275 */ 276 static inline struct drm_plane_state * 277 drm_atomic_get_existing_plane_state(struct drm_atomic_state *state, 278 struct drm_plane *plane) 279 { 280 return state->planes[drm_plane_index(plane)].state; 281 } 282 283 /** 284 * drm_atomic_get_existing_connector_state - get connector state, if it exists 285 * @state: global atomic state object 286 * @connector: connector to grab 287 * 288 * This function returns the connector state for the given connector, 289 * or NULL if the connector is not part of the global atomic state. 290 */ 291 static inline struct drm_connector_state * 292 drm_atomic_get_existing_connector_state(struct drm_atomic_state *state, 293 struct drm_connector *connector) 294 { 295 int index = drm_connector_index(connector); 296 297 if (index >= state->num_connector) 298 return NULL; 299 300 return state->connectors[index].state; 301 } 302 303 /** 304 * __drm_atomic_get_current_plane_state - get current plane state 305 * @state: global atomic state object 306 * @plane: plane to grab 307 * 308 * This function returns the plane state for the given plane, either from 309 * @state, or if the plane isn't part of the atomic state update, from @plane. 310 * This is useful in atomic check callbacks, when drivers need to peek at, but 311 * not change, state of other planes, since it avoids threading an error code 312 * back up the call chain. 313 * 314 * WARNING: 315 * 316 * Note that this function is in general unsafe since it doesn't check for the 317 * required locking for access state structures. Drivers must ensure that it is 318 * safe to access the returned state structure through other means. One common 319 * example is when planes are fixed to a single CRTC, and the driver knows that 320 * the CRTC lock is held already. In that case holding the CRTC lock gives a 321 * read-lock on all planes connected to that CRTC. But if planes can be 322 * reassigned things get more tricky. In that case it's better to use 323 * drm_atomic_get_plane_state and wire up full error handling. 324 * 325 * Returns: 326 * 327 * Read-only pointer to the current plane state. 328 */ 329 static inline const struct drm_plane_state * 330 __drm_atomic_get_current_plane_state(struct drm_atomic_state *state, 331 struct drm_plane *plane) 332 { 333 if (state->planes[drm_plane_index(plane)].state) 334 return state->planes[drm_plane_index(plane)].state; 335 336 return plane->state; 337 } 338 339 int __must_check 340 drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state, 341 struct drm_display_mode *mode); 342 int __must_check 343 drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, 344 struct drm_property_blob *blob); 345 int __must_check 346 drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state, 347 struct drm_crtc *crtc); 348 void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, 349 struct drm_framebuffer *fb); 350 void drm_atomic_set_fence_for_plane(struct drm_plane_state *plane_state, 351 struct dma_fence *fence); 352 int __must_check 353 drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, 354 struct drm_crtc *crtc); 355 int __must_check 356 drm_atomic_add_affected_connectors(struct drm_atomic_state *state, 357 struct drm_crtc *crtc); 358 int __must_check 359 drm_atomic_add_affected_planes(struct drm_atomic_state *state, 360 struct drm_crtc *crtc); 361 362 void drm_atomic_legacy_backoff(struct drm_atomic_state *state); 363 364 void 365 drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret); 366 367 int __must_check drm_atomic_check_only(struct drm_atomic_state *state); 368 int __must_check drm_atomic_commit(struct drm_atomic_state *state); 369 int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); 370 371 void drm_state_dump(struct drm_device *dev, struct drm_printer *p); 372 373 #define for_each_connector_in_state(__state, connector, connector_state, __i) \ 374 for ((__i) = 0; \ 375 (__i) < (__state)->num_connector && \ 376 ((connector) = (__state)->connectors[__i].ptr, \ 377 (connector_state) = (__state)->connectors[__i].state, 1); \ 378 (__i)++) \ 379 for_each_if (connector) 380 381 #define for_each_crtc_in_state(__state, crtc, crtc_state, __i) \ 382 for ((__i) = 0; \ 383 (__i) < (__state)->dev->mode_config.num_crtc && \ 384 ((crtc) = (__state)->crtcs[__i].ptr, \ 385 (crtc_state) = (__state)->crtcs[__i].state, 1); \ 386 (__i)++) \ 387 for_each_if (crtc_state) 388 389 #define for_each_plane_in_state(__state, plane, plane_state, __i) \ 390 for ((__i) = 0; \ 391 (__i) < (__state)->dev->mode_config.num_total_plane && \ 392 ((plane) = (__state)->planes[__i].ptr, \ 393 (plane_state) = (__state)->planes[__i].state, 1); \ 394 (__i)++) \ 395 for_each_if (plane_state) 396 397 /** 398 * drm_atomic_crtc_needs_modeset - compute combined modeset need 399 * @state: &drm_crtc_state for the CRTC 400 * 401 * To give drivers flexibility struct &drm_crtc_state has 3 booleans to track 402 * whether the state CRTC changed enough to need a full modeset cycle: 403 * connectors_changed, mode_changed and active_changed. This helper simply 404 * combines these three to compute the overall need for a modeset for @state. 405 * 406 * The atomic helper code sets these booleans, but drivers can and should 407 * change them appropriately to accurately represent whether a modeset is 408 * really needed. In general, drivers should avoid full modesets whenever 409 * possible. 410 * 411 * For example if the CRTC mode has changed, and the hardware is able to enact 412 * the requested mode change without going through a full modeset, the driver 413 * should clear mode_changed during its ->atomic_check. 414 */ 415 static inline bool 416 drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) 417 { 418 return state->mode_changed || state->active_changed || 419 state->connectors_changed; 420 } 421 422 #endif /* DRM_ATOMIC_H_ */ 423