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