1 /* $NetBSD: drm_atomic.c,v 1.13 2021/12/23 17:11:41 hannken Exp $ */
2
3 /*
4 * Copyright (C) 2014 Red Hat
5 * Copyright (C) 2014 Intel Corp.
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 * Authors:
26 * Rob Clark <robdclark@gmail.com>
27 * Daniel Vetter <daniel.vetter@ffwll.ch>
28 */
29
30
31 #include <sys/cdefs.h>
32 __KERNEL_RCSID(0, "$NetBSD: drm_atomic.c,v 1.13 2021/12/23 17:11:41 hannken Exp $");
33
34 #include <linux/sync_file.h>
35
36 #include <drm/drm_atomic.h>
37 #include <drm/drm_atomic_uapi.h>
38 #include <drm/drm_debugfs.h>
39 #include <drm/drm_device.h>
40 #include <drm/drm_drv.h>
41 #include <drm/drm_file.h>
42 #include <drm/drm_fourcc.h>
43 #include <drm/drm_mode.h>
44 #include <drm/drm_print.h>
45 #include <drm/drm_writeback.h>
46
47 #include "drm_crtc_internal.h"
48 #include "drm_internal.h"
49
__drm_crtc_commit_free(struct kref * kref)50 void __drm_crtc_commit_free(struct kref *kref)
51 {
52 struct drm_crtc_commit *commit =
53 container_of(kref, struct drm_crtc_commit, ref);
54
55 #ifdef __NetBSD__
56 destroy_completion(&commit->flip_done);
57 destroy_completion(&commit->hw_done);
58 destroy_completion(&commit->cleanup_done);
59 #endif
60 kfree(commit);
61 }
62 EXPORT_SYMBOL(__drm_crtc_commit_free);
63
64 /**
65 * drm_atomic_state_default_release -
66 * release memory initialized by drm_atomic_state_init
67 * @state: atomic state
68 *
69 * Free all the memory allocated by drm_atomic_state_init.
70 * This should only be used by drivers which are still subclassing
71 * &drm_atomic_state and haven't switched to &drm_private_state yet.
72 */
drm_atomic_state_default_release(struct drm_atomic_state * state)73 void drm_atomic_state_default_release(struct drm_atomic_state *state)
74 {
75 kfree(state->connectors);
76 kfree(state->crtcs);
77 kfree(state->planes);
78 kfree(state->private_objs);
79 }
80 EXPORT_SYMBOL(drm_atomic_state_default_release);
81
82 /**
83 * drm_atomic_state_init - init new atomic state
84 * @dev: DRM device
85 * @state: atomic state
86 *
87 * Default implementation for filling in a new atomic state.
88 * This should only be used by drivers which are still subclassing
89 * &drm_atomic_state and haven't switched to &drm_private_state yet.
90 */
91 int
drm_atomic_state_init(struct drm_device * dev,struct drm_atomic_state * state)92 drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
93 {
94 kref_init(&state->ref);
95
96 /* TODO legacy paths should maybe do a better job about
97 * setting this appropriately?
98 */
99 state->allow_modeset = true;
100
101 state->crtcs = kcalloc(dev->mode_config.num_crtc,
102 sizeof(*state->crtcs), GFP_KERNEL);
103 if (!state->crtcs)
104 goto fail;
105 state->planes = kcalloc(dev->mode_config.num_total_plane,
106 sizeof(*state->planes), GFP_KERNEL);
107 if (!state->planes)
108 goto fail;
109
110 state->dev = dev;
111
112 DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
113
114 return 0;
115 fail:
116 drm_atomic_state_default_release(state);
117 return -ENOMEM;
118 }
119 EXPORT_SYMBOL(drm_atomic_state_init);
120
121 /**
122 * drm_atomic_state_alloc - allocate atomic state
123 * @dev: DRM device
124 *
125 * This allocates an empty atomic state to track updates.
126 */
127 struct drm_atomic_state *
drm_atomic_state_alloc(struct drm_device * dev)128 drm_atomic_state_alloc(struct drm_device *dev)
129 {
130 struct drm_mode_config *config = &dev->mode_config;
131
132 if (!config->funcs->atomic_state_alloc) {
133 struct drm_atomic_state *state;
134
135 state = kzalloc(sizeof(*state), GFP_KERNEL);
136 if (!state)
137 return NULL;
138 if (drm_atomic_state_init(dev, state) < 0) {
139 kfree(state);
140 return NULL;
141 }
142 return state;
143 }
144
145 return config->funcs->atomic_state_alloc(dev);
146 }
147 EXPORT_SYMBOL(drm_atomic_state_alloc);
148
149 /**
150 * drm_atomic_state_default_clear - clear base atomic state
151 * @state: atomic state
152 *
153 * Default implementation for clearing atomic state.
154 * This should only be used by drivers which are still subclassing
155 * &drm_atomic_state and haven't switched to &drm_private_state yet.
156 */
drm_atomic_state_default_clear(struct drm_atomic_state * state)157 void drm_atomic_state_default_clear(struct drm_atomic_state *state)
158 {
159 struct drm_device *dev = state->dev;
160 struct drm_mode_config *config = &dev->mode_config;
161 int i;
162
163 DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
164
165 for (i = 0; i < state->num_connector; i++) {
166 struct drm_connector *connector = state->connectors[i].ptr;
167
168 if (!connector)
169 continue;
170
171 connector->funcs->atomic_destroy_state(connector,
172 state->connectors[i].state);
173 state->connectors[i].ptr = NULL;
174 state->connectors[i].state = NULL;
175 state->connectors[i].old_state = NULL;
176 state->connectors[i].new_state = NULL;
177 drm_connector_put(connector);
178 }
179
180 for (i = 0; i < config->num_crtc; i++) {
181 struct drm_crtc *crtc = state->crtcs[i].ptr;
182
183 if (!crtc)
184 continue;
185
186 crtc->funcs->atomic_destroy_state(crtc,
187 state->crtcs[i].state);
188
189 state->crtcs[i].ptr = NULL;
190 state->crtcs[i].state = NULL;
191 state->crtcs[i].old_state = NULL;
192 state->crtcs[i].new_state = NULL;
193
194 if (state->crtcs[i].commit) {
195 drm_crtc_commit_put(state->crtcs[i].commit);
196 state->crtcs[i].commit = NULL;
197 }
198 }
199
200 for (i = 0; i < config->num_total_plane; i++) {
201 struct drm_plane *plane = state->planes[i].ptr;
202
203 if (!plane)
204 continue;
205
206 plane->funcs->atomic_destroy_state(plane,
207 state->planes[i].state);
208 state->planes[i].ptr = NULL;
209 state->planes[i].state = NULL;
210 state->planes[i].old_state = NULL;
211 state->planes[i].new_state = NULL;
212 }
213
214 for (i = 0; i < state->num_private_objs; i++) {
215 struct drm_private_obj *obj = state->private_objs[i].ptr;
216
217 obj->funcs->atomic_destroy_state(obj,
218 state->private_objs[i].state);
219 state->private_objs[i].ptr = NULL;
220 state->private_objs[i].state = NULL;
221 state->private_objs[i].old_state = NULL;
222 state->private_objs[i].new_state = NULL;
223 }
224 state->num_private_objs = 0;
225
226 if (state->fake_commit) {
227 drm_crtc_commit_put(state->fake_commit);
228 state->fake_commit = NULL;
229 }
230 }
231 EXPORT_SYMBOL(drm_atomic_state_default_clear);
232
233 /**
234 * drm_atomic_state_clear - clear state object
235 * @state: atomic state
236 *
237 * When the w/w mutex algorithm detects a deadlock we need to back off and drop
238 * all locks. So someone else could sneak in and change the current modeset
239 * configuration. Which means that all the state assembled in @state is no
240 * longer an atomic update to the current state, but to some arbitrary earlier
241 * state. Which could break assumptions the driver's
242 * &drm_mode_config_funcs.atomic_check likely relies on.
243 *
244 * Hence we must clear all cached state and completely start over, using this
245 * function.
246 */
drm_atomic_state_clear(struct drm_atomic_state * state)247 void drm_atomic_state_clear(struct drm_atomic_state *state)
248 {
249 struct drm_device *dev = state->dev;
250 struct drm_mode_config *config = &dev->mode_config;
251
252 if (config->funcs->atomic_state_clear)
253 config->funcs->atomic_state_clear(state);
254 else
255 drm_atomic_state_default_clear(state);
256 }
257 EXPORT_SYMBOL(drm_atomic_state_clear);
258
259 /**
260 * __drm_atomic_state_free - free all memory for an atomic state
261 * @ref: This atomic state to deallocate
262 *
263 * This frees all memory associated with an atomic state, including all the
264 * per-object state for planes, CRTCs and connectors.
265 */
__drm_atomic_state_free(struct kref * ref)266 void __drm_atomic_state_free(struct kref *ref)
267 {
268 struct drm_atomic_state *state = container_of(ref, typeof(*state), ref);
269 struct drm_mode_config *config = &state->dev->mode_config;
270
271 drm_atomic_state_clear(state);
272
273 DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
274
275 if (config->funcs->atomic_state_free) {
276 config->funcs->atomic_state_free(state);
277 } else {
278 drm_atomic_state_default_release(state);
279 kfree(state);
280 }
281 }
282 EXPORT_SYMBOL(__drm_atomic_state_free);
283
284 /**
285 * drm_atomic_get_crtc_state - get CRTC state
286 * @state: global atomic state object
287 * @crtc: CRTC to get state object for
288 *
289 * This function returns the CRTC state for the given CRTC, allocating it if
290 * needed. It will also grab the relevant CRTC lock to make sure that the state
291 * is consistent.
292 *
293 * Returns:
294 *
295 * Either the allocated state or the error code encoded into the pointer. When
296 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
297 * entire atomic sequence must be restarted. All other errors are fatal.
298 */
299 struct drm_crtc_state *
drm_atomic_get_crtc_state(struct drm_atomic_state * state,struct drm_crtc * crtc)300 drm_atomic_get_crtc_state(struct drm_atomic_state *state,
301 struct drm_crtc *crtc)
302 {
303 int ret, index = drm_crtc_index(crtc);
304 struct drm_crtc_state *crtc_state;
305
306 WARN_ON(!state->acquire_ctx);
307
308 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
309 if (crtc_state)
310 return crtc_state;
311
312 ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
313 if (ret)
314 return ERR_PTR(ret);
315
316 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
317 if (!crtc_state)
318 return ERR_PTR(-ENOMEM);
319
320 state->crtcs[index].state = crtc_state;
321 state->crtcs[index].old_state = crtc->state;
322 state->crtcs[index].new_state = crtc_state;
323 state->crtcs[index].ptr = crtc;
324 crtc_state->state = state;
325
326 DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
327 crtc->base.id, crtc->name, crtc_state, state);
328
329 return crtc_state;
330 }
331 EXPORT_SYMBOL(drm_atomic_get_crtc_state);
332
drm_atomic_crtc_check(const struct drm_crtc_state * old_crtc_state,const struct drm_crtc_state * new_crtc_state)333 static int drm_atomic_crtc_check(const struct drm_crtc_state *old_crtc_state,
334 const struct drm_crtc_state *new_crtc_state)
335 {
336 struct drm_crtc *crtc = new_crtc_state->crtc;
337
338 /* NOTE: we explicitly don't enforce constraints such as primary
339 * layer covering entire screen, since that is something we want
340 * to allow (on hw that supports it). For hw that does not, it
341 * should be checked in driver's crtc->atomic_check() vfunc.
342 *
343 * TODO: Add generic modeset state checks once we support those.
344 */
345
346 if (new_crtc_state->active && !new_crtc_state->enable) {
347 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
348 crtc->base.id, crtc->name);
349 return -EINVAL;
350 }
351
352 /* The state->enable vs. state->mode_blob checks can be WARN_ON,
353 * as this is a kernel-internal detail that userspace should never
354 * be able to trigger. */
355 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
356 WARN_ON(new_crtc_state->enable && !new_crtc_state->mode_blob)) {
357 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
358 crtc->base.id, crtc->name);
359 return -EINVAL;
360 }
361
362 if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
363 WARN_ON(!new_crtc_state->enable && new_crtc_state->mode_blob)) {
364 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
365 crtc->base.id, crtc->name);
366 return -EINVAL;
367 }
368
369 /*
370 * Reject event generation for when a CRTC is off and stays off.
371 * It wouldn't be hard to implement this, but userspace has a track
372 * record of happily burning through 100% cpu (or worse, crash) when the
373 * display pipe is suspended. To avoid all that fun just reject updates
374 * that ask for events since likely that indicates a bug in the
375 * compositor's drawing loop. This is consistent with the vblank IOCTL
376 * and legacy page_flip IOCTL which also reject service on a disabled
377 * pipe.
378 */
379 if (new_crtc_state->event &&
380 !new_crtc_state->active && !old_crtc_state->active) {
381 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requesting event but off\n",
382 crtc->base.id, crtc->name);
383 return -EINVAL;
384 }
385
386 return 0;
387 }
388
drm_atomic_crtc_print_state(struct drm_printer * p,const struct drm_crtc_state * state)389 static void drm_atomic_crtc_print_state(struct drm_printer *p,
390 const struct drm_crtc_state *state)
391 {
392 struct drm_crtc *crtc = state->crtc;
393
394 drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name);
395 drm_printf(p, "\tenable=%d\n", state->enable);
396 drm_printf(p, "\tactive=%d\n", state->active);
397 drm_printf(p, "\tself_refresh_active=%d\n", state->self_refresh_active);
398 drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed);
399 drm_printf(p, "\tmode_changed=%d\n", state->mode_changed);
400 drm_printf(p, "\tactive_changed=%d\n", state->active_changed);
401 drm_printf(p, "\tconnectors_changed=%d\n", state->connectors_changed);
402 drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed);
403 drm_printf(p, "\tplane_mask=%x\n", state->plane_mask);
404 drm_printf(p, "\tconnector_mask=%x\n", state->connector_mask);
405 drm_printf(p, "\tencoder_mask=%x\n", state->encoder_mask);
406 drm_printf(p, "\tmode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(&state->mode));
407
408 if (crtc->funcs->atomic_print_state)
409 crtc->funcs->atomic_print_state(p, state);
410 }
411
drm_atomic_connector_check(struct drm_connector * connector,struct drm_connector_state * state)412 static int drm_atomic_connector_check(struct drm_connector *connector,
413 struct drm_connector_state *state)
414 {
415 struct drm_crtc_state *crtc_state;
416 struct drm_writeback_job *writeback_job = state->writeback_job;
417 const struct drm_display_info *info = &connector->display_info;
418
419 crtc_state = NULL; /* GCC */
420 state->max_bpc = info->bpc ? info->bpc : 8;
421 if (connector->max_bpc_property)
422 state->max_bpc = min(state->max_bpc, state->max_requested_bpc);
423
424 if ((connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK) || !writeback_job)
425 return 0;
426
427 if (writeback_job->fb && !state->crtc) {
428 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] framebuffer without CRTC\n",
429 connector->base.id, connector->name);
430 return -EINVAL;
431 }
432
433 if (state->crtc)
434 crtc_state = drm_atomic_get_existing_crtc_state(state->state,
435 state->crtc);
436
437 if (writeback_job->fb && !crtc_state->active) {
438 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] has framebuffer, but [CRTC:%d] is off\n",
439 connector->base.id, connector->name,
440 state->crtc->base.id);
441 return -EINVAL;
442 }
443
444 if (!writeback_job->fb) {
445 if (writeback_job->out_fence) {
446 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n",
447 connector->base.id, connector->name);
448 return -EINVAL;
449 }
450
451 drm_writeback_cleanup_job(writeback_job);
452 state->writeback_job = NULL;
453 }
454
455 return 0;
456 }
457
458 /**
459 * drm_atomic_get_plane_state - get plane state
460 * @state: global atomic state object
461 * @plane: plane to get state object for
462 *
463 * This function returns the plane state for the given plane, allocating it if
464 * needed. It will also grab the relevant plane lock to make sure that the state
465 * is consistent.
466 *
467 * Returns:
468 *
469 * Either the allocated state or the error code encoded into the pointer. When
470 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
471 * entire atomic sequence must be restarted. All other errors are fatal.
472 */
473 struct drm_plane_state *
drm_atomic_get_plane_state(struct drm_atomic_state * state,struct drm_plane * plane)474 drm_atomic_get_plane_state(struct drm_atomic_state *state,
475 struct drm_plane *plane)
476 {
477 int ret, index = drm_plane_index(plane);
478 struct drm_plane_state *plane_state;
479
480 WARN_ON(!state->acquire_ctx);
481
482 /* the legacy pointers should never be set */
483 WARN_ON(plane->fb);
484 WARN_ON(plane->old_fb);
485 WARN_ON(plane->crtc);
486
487 plane_state = drm_atomic_get_existing_plane_state(state, plane);
488 if (plane_state)
489 return plane_state;
490
491 ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
492 if (ret)
493 return ERR_PTR(ret);
494
495 plane_state = plane->funcs->atomic_duplicate_state(plane);
496 if (!plane_state)
497 return ERR_PTR(-ENOMEM);
498
499 state->planes[index].state = plane_state;
500 state->planes[index].ptr = plane;
501 state->planes[index].old_state = plane->state;
502 state->planes[index].new_state = plane_state;
503 plane_state->state = state;
504
505 DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
506 plane->base.id, plane->name, plane_state, state);
507
508 if (plane_state->crtc) {
509 struct drm_crtc_state *crtc_state;
510
511 crtc_state = drm_atomic_get_crtc_state(state,
512 plane_state->crtc);
513 if (IS_ERR(crtc_state))
514 return ERR_CAST(crtc_state);
515 }
516
517 return plane_state;
518 }
519 EXPORT_SYMBOL(drm_atomic_get_plane_state);
520
521 static bool
plane_switching_crtc(const struct drm_plane_state * old_plane_state,const struct drm_plane_state * new_plane_state)522 plane_switching_crtc(const struct drm_plane_state *old_plane_state,
523 const struct drm_plane_state *new_plane_state)
524 {
525 if (!old_plane_state->crtc || !new_plane_state->crtc)
526 return false;
527
528 if (old_plane_state->crtc == new_plane_state->crtc)
529 return false;
530
531 /* This could be refined, but currently there's no helper or driver code
532 * to implement direct switching of active planes nor userspace to take
533 * advantage of more direct plane switching without the intermediate
534 * full OFF state.
535 */
536 return true;
537 }
538
539 /**
540 * drm_atomic_plane_check - check plane state
541 * @old_plane_state: old plane state to check
542 * @new_plane_state: new plane state to check
543 *
544 * Provides core sanity checks for plane state.
545 *
546 * RETURNS:
547 * Zero on success, error code on failure
548 */
drm_atomic_plane_check(const struct drm_plane_state * old_plane_state,const struct drm_plane_state * new_plane_state)549 static int drm_atomic_plane_check(const struct drm_plane_state *old_plane_state,
550 const struct drm_plane_state *new_plane_state)
551 {
552 struct drm_plane *plane = new_plane_state->plane;
553 struct drm_crtc *crtc = new_plane_state->crtc;
554 const struct drm_framebuffer *fb = new_plane_state->fb;
555 unsigned int fb_width, fb_height;
556 struct drm_mode_rect *clips;
557 uint32_t num_clips;
558 int ret;
559
560 /* either *both* CRTC and FB must be set, or neither */
561 if (crtc && !fb) {
562 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] CRTC set but no FB\n",
563 plane->base.id, plane->name);
564 return -EINVAL;
565 } else if (fb && !crtc) {
566 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] FB set but no CRTC\n",
567 plane->base.id, plane->name);
568 return -EINVAL;
569 }
570
571 /* if disabled, we don't care about the rest of the state: */
572 if (!crtc)
573 return 0;
574
575 /* Check whether this plane is usable on this CRTC */
576 if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
577 DRM_DEBUG_ATOMIC("Invalid [CRTC:%d:%s] for [PLANE:%d:%s]\n",
578 crtc->base.id, crtc->name,
579 plane->base.id, plane->name);
580 return -EINVAL;
581 }
582
583 /* Check whether this plane supports the fb pixel format. */
584 ret = drm_plane_check_pixel_format(plane, fb->format->format,
585 fb->modifier);
586 if (ret) {
587 struct drm_format_name_buf format_name;
588 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid pixel format %s, modifier 0x%"PRIx64"\n",
589 plane->base.id, plane->name,
590 drm_get_format_name(fb->format->format,
591 &format_name),
592 fb->modifier);
593 return ret;
594 }
595
596 /* Give drivers some help against integer overflows */
597 if (new_plane_state->crtc_w > INT_MAX ||
598 new_plane_state->crtc_x > INT_MAX - (int32_t) new_plane_state->crtc_w ||
599 new_plane_state->crtc_h > INT_MAX ||
600 new_plane_state->crtc_y > INT_MAX - (int32_t) new_plane_state->crtc_h) {
601 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid CRTC coordinates %ux%u+%d+%d\n",
602 plane->base.id, plane->name,
603 new_plane_state->crtc_w, new_plane_state->crtc_h,
604 new_plane_state->crtc_x, new_plane_state->crtc_y);
605 return -ERANGE;
606 }
607
608 fb_width = fb->width << 16;
609 fb_height = fb->height << 16;
610
611 /* Make sure source coordinates are inside the fb. */
612 if (new_plane_state->src_w > fb_width ||
613 new_plane_state->src_x > fb_width - new_plane_state->src_w ||
614 new_plane_state->src_h > fb_height ||
615 new_plane_state->src_y > fb_height - new_plane_state->src_h) {
616 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid source coordinates "
617 "%u.%06ux%u.%06u+%u.%06u+%u.%06u (fb %ux%u)\n",
618 plane->base.id, plane->name,
619 new_plane_state->src_w >> 16,
620 ((new_plane_state->src_w & 0xffff) * 15625) >> 10,
621 new_plane_state->src_h >> 16,
622 ((new_plane_state->src_h & 0xffff) * 15625) >> 10,
623 new_plane_state->src_x >> 16,
624 ((new_plane_state->src_x & 0xffff) * 15625) >> 10,
625 new_plane_state->src_y >> 16,
626 ((new_plane_state->src_y & 0xffff) * 15625) >> 10,
627 fb->width, fb->height);
628 return -ENOSPC;
629 }
630
631 clips = drm_plane_get_damage_clips(new_plane_state);
632 num_clips = drm_plane_get_damage_clips_count(new_plane_state);
633
634 /* Make sure damage clips are valid and inside the fb. */
635 while (num_clips > 0) {
636 if (clips->x1 >= clips->x2 ||
637 clips->y1 >= clips->y2 ||
638 clips->x1 < 0 ||
639 clips->y1 < 0 ||
640 clips->x2 > fb_width ||
641 clips->y2 > fb_height) {
642 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] invalid damage clip %d %d %d %d\n",
643 plane->base.id, plane->name, clips->x1,
644 clips->y1, clips->x2, clips->y2);
645 return -EINVAL;
646 }
647 clips++;
648 num_clips--;
649 }
650
651 if (plane_switching_crtc(old_plane_state, new_plane_state)) {
652 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
653 plane->base.id, plane->name);
654 return -EINVAL;
655 }
656
657 return 0;
658 }
659
drm_atomic_plane_print_state(struct drm_printer * p,const struct drm_plane_state * state)660 static void drm_atomic_plane_print_state(struct drm_printer *p,
661 const struct drm_plane_state *state)
662 {
663 struct drm_plane *plane = state->plane;
664 struct drm_rect src = drm_plane_state_src(state);
665 struct drm_rect dest = drm_plane_state_dest(state);
666
667 drm_printf(p, "plane[%u]: %s\n", plane->base.id, plane->name);
668 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
669 drm_printf(p, "\tfb=%u\n", state->fb ? state->fb->base.id : 0);
670 if (state->fb)
671 drm_framebuffer_print_info(p, 2, state->fb);
672 drm_printf(p, "\tcrtc-pos=" DRM_RECT_FMT "\n", DRM_RECT_ARG(&dest));
673 drm_printf(p, "\tsrc-pos=" DRM_RECT_FP_FMT "\n", DRM_RECT_FP_ARG(&src));
674 drm_printf(p, "\trotation=%x\n", state->rotation);
675 drm_printf(p, "\tnormalized-zpos=%x\n", state->normalized_zpos);
676 drm_printf(p, "\tcolor-encoding=%s\n",
677 drm_get_color_encoding_name(state->color_encoding));
678 drm_printf(p, "\tcolor-range=%s\n",
679 drm_get_color_range_name(state->color_range));
680
681 if (plane->funcs->atomic_print_state)
682 plane->funcs->atomic_print_state(p, state);
683 }
684
685 /**
686 * DOC: handling driver private state
687 *
688 * Very often the DRM objects exposed to userspace in the atomic modeset api
689 * (&drm_connector, &drm_crtc and &drm_plane) do not map neatly to the
690 * underlying hardware. Especially for any kind of shared resources (e.g. shared
691 * clocks, scaler units, bandwidth and fifo limits shared among a group of
692 * planes or CRTCs, and so on) it makes sense to model these as independent
693 * objects. Drivers then need to do similar state tracking and commit ordering for
694 * such private (since not exposed to userpace) objects as the atomic core and
695 * helpers already provide for connectors, planes and CRTCs.
696 *
697 * To make this easier on drivers the atomic core provides some support to track
698 * driver private state objects using struct &drm_private_obj, with the
699 * associated state struct &drm_private_state.
700 *
701 * Similar to userspace-exposed objects, private state structures can be
702 * acquired by calling drm_atomic_get_private_obj_state(). This also takes care
703 * of locking, hence drivers should not have a need to call drm_modeset_lock()
704 * directly. Sequence of the actual hardware state commit is not handled,
705 * drivers might need to keep track of struct drm_crtc_commit within subclassed
706 * structure of &drm_private_state as necessary, e.g. similar to
707 * &drm_plane_state.commit. See also &drm_atomic_state.fake_commit.
708 *
709 * All private state structures contained in a &drm_atomic_state update can be
710 * iterated using for_each_oldnew_private_obj_in_state(),
711 * for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state().
712 * Drivers are recommended to wrap these for each type of driver private state
713 * object they have, filtering on &drm_private_obj.funcs using for_each_if(), at
714 * least if they want to iterate over all objects of a given type.
715 *
716 * An earlier way to handle driver private state was by subclassing struct
717 * &drm_atomic_state. But since that encourages non-standard ways to implement
718 * the check/commit split atomic requires (by using e.g. "check and rollback or
719 * commit instead" of "duplicate state, check, then either commit or release
720 * duplicated state) it is deprecated in favour of using &drm_private_state.
721 */
722
723 /**
724 * drm_atomic_private_obj_init - initialize private object
725 * @dev: DRM device this object will be attached to
726 * @obj: private object
727 * @state: initial private object state
728 * @funcs: pointer to the struct of function pointers that identify the object
729 * type
730 *
731 * Initialize the private object, which can be embedded into any
732 * driver private object that needs its own atomic state.
733 */
734 void
drm_atomic_private_obj_init(struct drm_device * dev,struct drm_private_obj * obj,struct drm_private_state * state,const struct drm_private_state_funcs * funcs)735 drm_atomic_private_obj_init(struct drm_device *dev,
736 struct drm_private_obj *obj,
737 struct drm_private_state *state,
738 const struct drm_private_state_funcs *funcs)
739 {
740 memset(obj, 0, sizeof(*obj));
741
742 drm_modeset_lock_init(&obj->lock);
743
744 obj->state = state;
745 obj->funcs = funcs;
746 list_add_tail(&obj->head, &dev->mode_config.privobj_list);
747 }
748 EXPORT_SYMBOL(drm_atomic_private_obj_init);
749
750 /**
751 * drm_atomic_private_obj_fini - finalize private object
752 * @obj: private object
753 *
754 * Finalize the private object.
755 */
756 void
drm_atomic_private_obj_fini(struct drm_private_obj * obj)757 drm_atomic_private_obj_fini(struct drm_private_obj *obj)
758 {
759 list_del(&obj->head);
760 obj->funcs->atomic_destroy_state(obj, obj->state);
761 drm_modeset_lock_fini(&obj->lock);
762 }
763 EXPORT_SYMBOL(drm_atomic_private_obj_fini);
764
765 /**
766 * drm_atomic_get_private_obj_state - get private object state
767 * @state: global atomic state
768 * @obj: private object to get the state for
769 *
770 * This function returns the private object state for the given private object,
771 * allocating the state if needed. It will also grab the relevant private
772 * object lock to make sure that the state is consistent.
773 *
774 * RETURNS:
775 *
776 * Either the allocated state or the error code encoded into a pointer.
777 */
778 struct drm_private_state *
drm_atomic_get_private_obj_state(struct drm_atomic_state * state,struct drm_private_obj * obj)779 drm_atomic_get_private_obj_state(struct drm_atomic_state *state,
780 struct drm_private_obj *obj)
781 {
782 int index, num_objs, i, ret;
783 size_t size;
784 struct __drm_private_objs_state *arr;
785 struct drm_private_state *obj_state;
786
787 for (i = 0; i < state->num_private_objs; i++)
788 if (obj == state->private_objs[i].ptr)
789 return state->private_objs[i].state;
790
791 ret = drm_modeset_lock(&obj->lock, state->acquire_ctx);
792 if (ret)
793 return ERR_PTR(ret);
794
795 num_objs = state->num_private_objs + 1;
796 size = sizeof(*state->private_objs) * num_objs;
797 arr = krealloc(state->private_objs, size, GFP_KERNEL);
798 if (!arr)
799 return ERR_PTR(-ENOMEM);
800
801 state->private_objs = arr;
802 index = state->num_private_objs;
803 memset(&state->private_objs[index], 0, sizeof(*state->private_objs));
804
805 obj_state = obj->funcs->atomic_duplicate_state(obj);
806 if (!obj_state)
807 return ERR_PTR(-ENOMEM);
808
809 state->private_objs[index].state = obj_state;
810 state->private_objs[index].old_state = obj->state;
811 state->private_objs[index].new_state = obj_state;
812 state->private_objs[index].ptr = obj;
813 obj_state->state = state;
814
815 state->num_private_objs = num_objs;
816
817 DRM_DEBUG_ATOMIC("Added new private object %p state %p to %p\n",
818 obj, obj_state, state);
819
820 return obj_state;
821 }
822 EXPORT_SYMBOL(drm_atomic_get_private_obj_state);
823
824 /**
825 * drm_atomic_get_old_private_obj_state
826 * @state: global atomic state object
827 * @obj: private_obj to grab
828 *
829 * This function returns the old private object state for the given private_obj,
830 * or NULL if the private_obj is not part of the global atomic state.
831 */
832 struct drm_private_state *
drm_atomic_get_old_private_obj_state(struct drm_atomic_state * state,struct drm_private_obj * obj)833 drm_atomic_get_old_private_obj_state(struct drm_atomic_state *state,
834 struct drm_private_obj *obj)
835 {
836 int i;
837
838 for (i = 0; i < state->num_private_objs; i++)
839 if (obj == state->private_objs[i].ptr)
840 return state->private_objs[i].old_state;
841
842 return NULL;
843 }
844 EXPORT_SYMBOL(drm_atomic_get_old_private_obj_state);
845
846 /**
847 * drm_atomic_get_new_private_obj_state
848 * @state: global atomic state object
849 * @obj: private_obj to grab
850 *
851 * This function returns the new private object state for the given private_obj,
852 * or NULL if the private_obj is not part of the global atomic state.
853 */
854 struct drm_private_state *
drm_atomic_get_new_private_obj_state(struct drm_atomic_state * state,struct drm_private_obj * obj)855 drm_atomic_get_new_private_obj_state(struct drm_atomic_state *state,
856 struct drm_private_obj *obj)
857 {
858 int i;
859
860 for (i = 0; i < state->num_private_objs; i++)
861 if (obj == state->private_objs[i].ptr)
862 return state->private_objs[i].new_state;
863
864 return NULL;
865 }
866 EXPORT_SYMBOL(drm_atomic_get_new_private_obj_state);
867
868 /**
869 * drm_atomic_get_old_connector_for_encoder - Get old connector for an encoder
870 * @state: Atomic state
871 * @encoder: The encoder to fetch the connector state for
872 *
873 * This function finds and returns the connector that was connected to @encoder
874 * as specified by the @state.
875 *
876 * If there is no connector in @state which previously had @encoder connected to
877 * it, this function will return NULL. While this may seem like an invalid use
878 * case, it is sometimes useful to differentiate commits which had no prior
879 * connectors attached to @encoder vs ones that did (and to inspect their
880 * state). This is especially true in enable hooks because the pipeline has
881 * changed.
882 *
883 * Returns: The old connector connected to @encoder, or NULL if the encoder is
884 * not connected.
885 */
886 struct drm_connector *
drm_atomic_get_old_connector_for_encoder(struct drm_atomic_state * state,struct drm_encoder * encoder)887 drm_atomic_get_old_connector_for_encoder(struct drm_atomic_state *state,
888 struct drm_encoder *encoder)
889 {
890 struct drm_connector_state *conn_state;
891 struct drm_connector *connector;
892 unsigned int i;
893
894 for_each_old_connector_in_state(state, connector, conn_state, i) {
895 if (conn_state->best_encoder == encoder)
896 return connector;
897 }
898
899 return NULL;
900 }
901 EXPORT_SYMBOL(drm_atomic_get_old_connector_for_encoder);
902
903 /**
904 * drm_atomic_get_new_connector_for_encoder - Get new connector for an encoder
905 * @state: Atomic state
906 * @encoder: The encoder to fetch the connector state for
907 *
908 * This function finds and returns the connector that will be connected to
909 * @encoder as specified by the @state.
910 *
911 * If there is no connector in @state which will have @encoder connected to it,
912 * this function will return NULL. While this may seem like an invalid use case,
913 * it is sometimes useful to differentiate commits which have no connectors
914 * attached to @encoder vs ones that do (and to inspect their state). This is
915 * especially true in disable hooks because the pipeline will change.
916 *
917 * Returns: The new connector connected to @encoder, or NULL if the encoder is
918 * not connected.
919 */
920 struct drm_connector *
drm_atomic_get_new_connector_for_encoder(struct drm_atomic_state * state,struct drm_encoder * encoder)921 drm_atomic_get_new_connector_for_encoder(struct drm_atomic_state *state,
922 struct drm_encoder *encoder)
923 {
924 struct drm_connector_state *conn_state;
925 struct drm_connector *connector;
926 unsigned int i;
927
928 for_each_new_connector_in_state(state, connector, conn_state, i) {
929 if (conn_state->best_encoder == encoder)
930 return connector;
931 }
932
933 return NULL;
934 }
935 EXPORT_SYMBOL(drm_atomic_get_new_connector_for_encoder);
936
937 /**
938 * drm_atomic_get_connector_state - get connector state
939 * @state: global atomic state object
940 * @connector: connector to get state object for
941 *
942 * This function returns the connector state for the given connector,
943 * allocating it if needed. It will also grab the relevant connector lock to
944 * make sure that the state is consistent.
945 *
946 * Returns:
947 *
948 * Either the allocated state or the error code encoded into the pointer. When
949 * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
950 * entire atomic sequence must be restarted. All other errors are fatal.
951 */
952 struct drm_connector_state *
drm_atomic_get_connector_state(struct drm_atomic_state * state,struct drm_connector * connector)953 drm_atomic_get_connector_state(struct drm_atomic_state *state,
954 struct drm_connector *connector)
955 {
956 int ret, index;
957 struct drm_mode_config *config = &connector->dev->mode_config;
958 struct drm_connector_state *connector_state;
959
960 WARN_ON(!state->acquire_ctx);
961
962 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
963 if (ret)
964 return ERR_PTR(ret);
965
966 index = drm_connector_index(connector);
967
968 if (index >= state->num_connector) {
969 struct __drm_connnectors_state *c;
970 int alloc = max(index + 1, config->num_connector);
971
972 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
973 if (!c)
974 return ERR_PTR(-ENOMEM);
975
976 state->connectors = c;
977 memset(&state->connectors[state->num_connector], 0,
978 sizeof(*state->connectors) * (alloc - state->num_connector));
979
980 state->num_connector = alloc;
981 }
982
983 if (state->connectors[index].state)
984 return state->connectors[index].state;
985
986 connector_state = connector->funcs->atomic_duplicate_state(connector);
987 if (!connector_state)
988 return ERR_PTR(-ENOMEM);
989
990 drm_connector_get(connector);
991 state->connectors[index].state = connector_state;
992 state->connectors[index].old_state = connector->state;
993 state->connectors[index].new_state = connector_state;
994 state->connectors[index].ptr = connector;
995 connector_state->state = state;
996
997 DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d:%s] %p state to %p\n",
998 connector->base.id, connector->name,
999 connector_state, state);
1000
1001 if (connector_state->crtc) {
1002 struct drm_crtc_state *crtc_state;
1003
1004 crtc_state = drm_atomic_get_crtc_state(state,
1005 connector_state->crtc);
1006 if (IS_ERR(crtc_state))
1007 return ERR_CAST(crtc_state);
1008 }
1009
1010 return connector_state;
1011 }
1012 EXPORT_SYMBOL(drm_atomic_get_connector_state);
1013
drm_atomic_connector_print_state(struct drm_printer * p,const struct drm_connector_state * state)1014 static void drm_atomic_connector_print_state(struct drm_printer *p,
1015 const struct drm_connector_state *state)
1016 {
1017 struct drm_connector *connector = state->connector;
1018
1019 drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name);
1020 drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
1021 drm_printf(p, "\tself_refresh_aware=%d\n", state->self_refresh_aware);
1022
1023 if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
1024 if (state->writeback_job && state->writeback_job->fb)
1025 drm_printf(p, "\tfb=%d\n", state->writeback_job->fb->base.id);
1026
1027 if (connector->funcs->atomic_print_state)
1028 connector->funcs->atomic_print_state(p, state);
1029 }
1030
1031 /**
1032 * drm_atomic_add_affected_connectors - add connectors for CRTC
1033 * @state: atomic state
1034 * @crtc: DRM CRTC
1035 *
1036 * This function walks the current configuration and adds all connectors
1037 * currently using @crtc to the atomic configuration @state. Note that this
1038 * function must acquire the connection mutex. This can potentially cause
1039 * unneeded seralization if the update is just for the planes on one CRTC. Hence
1040 * drivers and helpers should only call this when really needed (e.g. when a
1041 * full modeset needs to happen due to some change).
1042 *
1043 * Returns:
1044 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1045 * then the w/w mutex code has detected a deadlock and the entire atomic
1046 * sequence must be restarted. All other errors are fatal.
1047 */
1048 int
drm_atomic_add_affected_connectors(struct drm_atomic_state * state,struct drm_crtc * crtc)1049 drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
1050 struct drm_crtc *crtc)
1051 {
1052 struct drm_mode_config *config = &state->dev->mode_config;
1053 struct drm_connector *connector;
1054 struct drm_connector_state *conn_state;
1055 struct drm_connector_list_iter conn_iter;
1056 struct drm_crtc_state *crtc_state;
1057 int ret;
1058
1059 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1060 if (IS_ERR(crtc_state))
1061 return PTR_ERR(crtc_state);
1062
1063 ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
1064 if (ret)
1065 return ret;
1066
1067 DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
1068 crtc->base.id, crtc->name, state);
1069
1070 /*
1071 * Changed connectors are already in @state, so only need to look
1072 * at the connector_mask in crtc_state.
1073 */
1074 drm_connector_list_iter_begin(state->dev, &conn_iter);
1075 drm_for_each_connector_iter(connector, &conn_iter) {
1076 if (!(crtc_state->connector_mask & drm_connector_mask(connector)))
1077 continue;
1078
1079 conn_state = drm_atomic_get_connector_state(state, connector);
1080 if (IS_ERR(conn_state)) {
1081 drm_connector_list_iter_end(&conn_iter);
1082 return PTR_ERR(conn_state);
1083 }
1084 }
1085 drm_connector_list_iter_end(&conn_iter);
1086
1087 return 0;
1088 }
1089 EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
1090
1091 /**
1092 * drm_atomic_add_affected_planes - add planes for CRTC
1093 * @state: atomic state
1094 * @crtc: DRM CRTC
1095 *
1096 * This function walks the current configuration and adds all planes
1097 * currently used by @crtc to the atomic configuration @state. This is useful
1098 * when an atomic commit also needs to check all currently enabled plane on
1099 * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
1100 * to avoid special code to force-enable all planes.
1101 *
1102 * Since acquiring a plane state will always also acquire the w/w mutex of the
1103 * current CRTC for that plane (if there is any) adding all the plane states for
1104 * a CRTC will not reduce parallism of atomic updates.
1105 *
1106 * Returns:
1107 * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
1108 * then the w/w mutex code has detected a deadlock and the entire atomic
1109 * sequence must be restarted. All other errors are fatal.
1110 */
1111 int
drm_atomic_add_affected_planes(struct drm_atomic_state * state,struct drm_crtc * crtc)1112 drm_atomic_add_affected_planes(struct drm_atomic_state *state,
1113 struct drm_crtc *crtc)
1114 {
1115 const struct drm_crtc_state *old_crtc_state =
1116 drm_atomic_get_old_crtc_state(state, crtc);
1117 struct drm_plane *plane;
1118
1119 WARN_ON(!drm_atomic_get_new_crtc_state(state, crtc));
1120
1121 DRM_DEBUG_ATOMIC("Adding all current planes for [CRTC:%d:%s] to %p\n",
1122 crtc->base.id, crtc->name, state);
1123
1124 drm_for_each_plane_mask(plane, state->dev, old_crtc_state->plane_mask) {
1125 struct drm_plane_state *plane_state =
1126 drm_atomic_get_plane_state(state, plane);
1127
1128 if (IS_ERR(plane_state))
1129 return PTR_ERR(plane_state);
1130 }
1131 return 0;
1132 }
1133 EXPORT_SYMBOL(drm_atomic_add_affected_planes);
1134
1135 /**
1136 * drm_atomic_check_only - check whether a given config would work
1137 * @state: atomic configuration to check
1138 *
1139 * Note that this function can return -EDEADLK if the driver needed to acquire
1140 * more locks but encountered a deadlock. The caller must then do the usual w/w
1141 * backoff dance and restart. All other errors are fatal.
1142 *
1143 * Returns:
1144 * 0 on success, negative error code on failure.
1145 */
drm_atomic_check_only(struct drm_atomic_state * state)1146 int drm_atomic_check_only(struct drm_atomic_state *state)
1147 {
1148 struct drm_device *dev = state->dev;
1149 struct drm_mode_config *config = &dev->mode_config;
1150 struct drm_plane *plane;
1151 struct drm_plane_state *old_plane_state;
1152 struct drm_plane_state *new_plane_state;
1153 struct drm_crtc *crtc;
1154 struct drm_crtc_state *old_crtc_state;
1155 struct drm_crtc_state *new_crtc_state;
1156 struct drm_connector *conn;
1157 struct drm_connector_state *conn_state;
1158 int i, ret = 0;
1159
1160 DRM_DEBUG_ATOMIC("checking %p\n", state);
1161
1162 for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) {
1163 ret = drm_atomic_plane_check(old_plane_state, new_plane_state);
1164 if (ret) {
1165 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
1166 plane->base.id, plane->name);
1167 return ret;
1168 }
1169 }
1170
1171 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
1172 ret = drm_atomic_crtc_check(old_crtc_state, new_crtc_state);
1173 if (ret) {
1174 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
1175 crtc->base.id, crtc->name);
1176 return ret;
1177 }
1178 }
1179
1180 for_each_new_connector_in_state(state, conn, conn_state, i) {
1181 ret = drm_atomic_connector_check(conn, conn_state);
1182 if (ret) {
1183 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] atomic core check failed\n",
1184 conn->base.id, conn->name);
1185 return ret;
1186 }
1187 }
1188
1189 if (config->funcs->atomic_check) {
1190 ret = config->funcs->atomic_check(state->dev, state);
1191
1192 if (ret) {
1193 DRM_DEBUG_ATOMIC("atomic driver check for %p failed: %d\n",
1194 state, ret);
1195 return ret;
1196 }
1197 }
1198
1199 if (!state->allow_modeset) {
1200 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1201 if (drm_atomic_crtc_needs_modeset(new_crtc_state)) {
1202 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
1203 crtc->base.id, crtc->name);
1204 return -EINVAL;
1205 }
1206 }
1207 }
1208
1209 return 0;
1210 }
1211 EXPORT_SYMBOL(drm_atomic_check_only);
1212
1213 /**
1214 * drm_atomic_commit - commit configuration atomically
1215 * @state: atomic configuration to check
1216 *
1217 * Note that this function can return -EDEADLK if the driver needed to acquire
1218 * more locks but encountered a deadlock. The caller must then do the usual w/w
1219 * backoff dance and restart. All other errors are fatal.
1220 *
1221 * This function will take its own reference on @state.
1222 * Callers should always release their reference with drm_atomic_state_put().
1223 *
1224 * Returns:
1225 * 0 on success, negative error code on failure.
1226 */
drm_atomic_commit(struct drm_atomic_state * state)1227 int drm_atomic_commit(struct drm_atomic_state *state)
1228 {
1229 struct drm_mode_config *config = &state->dev->mode_config;
1230 int ret;
1231
1232 ret = drm_atomic_check_only(state);
1233 if (ret)
1234 return ret;
1235
1236 DRM_DEBUG_ATOMIC("committing %p\n", state);
1237
1238 return config->funcs->atomic_commit(state->dev, state, false);
1239 }
1240 EXPORT_SYMBOL(drm_atomic_commit);
1241
1242 /**
1243 * drm_atomic_nonblocking_commit - atomic nonblocking commit
1244 * @state: atomic configuration to check
1245 *
1246 * Note that this function can return -EDEADLK if the driver needed to acquire
1247 * more locks but encountered a deadlock. The caller must then do the usual w/w
1248 * backoff dance and restart. All other errors are fatal.
1249 *
1250 * This function will take its own reference on @state.
1251 * Callers should always release their reference with drm_atomic_state_put().
1252 *
1253 * Returns:
1254 * 0 on success, negative error code on failure.
1255 */
drm_atomic_nonblocking_commit(struct drm_atomic_state * state)1256 int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
1257 {
1258 struct drm_mode_config *config = &state->dev->mode_config;
1259 int ret;
1260
1261 ret = drm_atomic_check_only(state);
1262 if (ret)
1263 return ret;
1264
1265 DRM_DEBUG_ATOMIC("committing %p nonblocking\n", state);
1266
1267 return config->funcs->atomic_commit(state->dev, state, true);
1268 }
1269 EXPORT_SYMBOL(drm_atomic_nonblocking_commit);
1270
1271 /* just used from drm-client and atomic-helper: */
__drm_atomic_helper_disable_plane(struct drm_plane * plane,struct drm_plane_state * plane_state)1272 int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
1273 struct drm_plane_state *plane_state)
1274 {
1275 int ret;
1276
1277 ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
1278 if (ret != 0)
1279 return ret;
1280
1281 drm_atomic_set_fb_for_plane(plane_state, NULL);
1282 plane_state->crtc_x = 0;
1283 plane_state->crtc_y = 0;
1284 plane_state->crtc_w = 0;
1285 plane_state->crtc_h = 0;
1286 plane_state->src_x = 0;
1287 plane_state->src_y = 0;
1288 plane_state->src_w = 0;
1289 plane_state->src_h = 0;
1290
1291 return 0;
1292 }
1293 EXPORT_SYMBOL(__drm_atomic_helper_disable_plane);
1294
update_output_state(struct drm_atomic_state * state,struct drm_mode_set * set)1295 static int update_output_state(struct drm_atomic_state *state,
1296 struct drm_mode_set *set)
1297 {
1298 struct drm_device *dev = set->crtc->dev;
1299 struct drm_crtc *crtc;
1300 struct drm_crtc_state *new_crtc_state;
1301 struct drm_connector *connector;
1302 struct drm_connector_state *new_conn_state;
1303 int ret, i;
1304
1305 ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
1306 state->acquire_ctx);
1307 if (ret)
1308 return ret;
1309
1310 /* First disable all connectors on the target crtc. */
1311 ret = drm_atomic_add_affected_connectors(state, set->crtc);
1312 if (ret)
1313 return ret;
1314
1315 for_each_new_connector_in_state(state, connector, new_conn_state, i) {
1316 if (new_conn_state->crtc == set->crtc) {
1317 ret = drm_atomic_set_crtc_for_connector(new_conn_state,
1318 NULL);
1319 if (ret)
1320 return ret;
1321
1322 /* Make sure legacy setCrtc always re-trains */
1323 new_conn_state->link_status = DRM_LINK_STATUS_GOOD;
1324 }
1325 }
1326
1327 /* Then set all connectors from set->connectors on the target crtc */
1328 for (i = 0; i < set->num_connectors; i++) {
1329 new_conn_state = drm_atomic_get_connector_state(state,
1330 set->connectors[i]);
1331 if (IS_ERR(new_conn_state))
1332 return PTR_ERR(new_conn_state);
1333
1334 ret = drm_atomic_set_crtc_for_connector(new_conn_state,
1335 set->crtc);
1336 if (ret)
1337 return ret;
1338 }
1339
1340 for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
1341 /*
1342 * Don't update ->enable for the CRTC in the set_config request,
1343 * since a mismatch would indicate a bug in the upper layers.
1344 * The actual modeset code later on will catch any
1345 * inconsistencies here.
1346 */
1347 if (crtc == set->crtc)
1348 continue;
1349
1350 if (!new_crtc_state->connector_mask) {
1351 ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state,
1352 NULL);
1353 if (ret < 0)
1354 return ret;
1355
1356 new_crtc_state->active = false;
1357 }
1358 }
1359
1360 return 0;
1361 }
1362
1363 /* just used from drm-client and atomic-helper: */
__drm_atomic_helper_set_config(struct drm_mode_set * set,struct drm_atomic_state * state)1364 int __drm_atomic_helper_set_config(struct drm_mode_set *set,
1365 struct drm_atomic_state *state)
1366 {
1367 struct drm_crtc_state *crtc_state;
1368 struct drm_plane_state *primary_state;
1369 struct drm_crtc *crtc = set->crtc;
1370 int hdisplay, vdisplay;
1371 int ret;
1372
1373 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1374 if (IS_ERR(crtc_state))
1375 return PTR_ERR(crtc_state);
1376
1377 primary_state = drm_atomic_get_plane_state(state, crtc->primary);
1378 if (IS_ERR(primary_state))
1379 return PTR_ERR(primary_state);
1380
1381 if (!set->mode) {
1382 WARN_ON(set->fb);
1383 WARN_ON(set->num_connectors);
1384
1385 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
1386 if (ret != 0)
1387 return ret;
1388
1389 crtc_state->active = false;
1390
1391 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
1392 if (ret != 0)
1393 return ret;
1394
1395 drm_atomic_set_fb_for_plane(primary_state, NULL);
1396
1397 goto commit;
1398 }
1399
1400 WARN_ON(!set->fb);
1401 WARN_ON(!set->num_connectors);
1402
1403 ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
1404 if (ret != 0)
1405 return ret;
1406
1407 crtc_state->active = true;
1408
1409 ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
1410 if (ret != 0)
1411 return ret;
1412
1413 drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay);
1414
1415 drm_atomic_set_fb_for_plane(primary_state, set->fb);
1416 primary_state->crtc_x = 0;
1417 primary_state->crtc_y = 0;
1418 primary_state->crtc_w = hdisplay;
1419 primary_state->crtc_h = vdisplay;
1420 primary_state->src_x = set->x << 16;
1421 primary_state->src_y = set->y << 16;
1422 if (drm_rotation_90_or_270(primary_state->rotation)) {
1423 primary_state->src_w = vdisplay << 16;
1424 primary_state->src_h = hdisplay << 16;
1425 } else {
1426 primary_state->src_w = hdisplay << 16;
1427 primary_state->src_h = vdisplay << 16;
1428 }
1429
1430 commit:
1431 ret = update_output_state(state, set);
1432 if (ret)
1433 return ret;
1434
1435 return 0;
1436 }
1437 EXPORT_SYMBOL(__drm_atomic_helper_set_config);
1438
drm_atomic_print_state(const struct drm_atomic_state * state)1439 void drm_atomic_print_state(const struct drm_atomic_state *state)
1440 {
1441 struct drm_printer p = drm_info_printer(state->dev->dev);
1442 struct drm_plane *plane __unused;
1443 struct drm_plane_state *plane_state;
1444 struct drm_crtc *crtc __unused;
1445 struct drm_crtc_state *crtc_state;
1446 struct drm_connector *connector __unused;
1447 struct drm_connector_state *connector_state;
1448 int i;
1449
1450 DRM_DEBUG_ATOMIC("checking %p\n", state);
1451
1452 for_each_new_plane_in_state(state, plane, plane_state, i)
1453 drm_atomic_plane_print_state(&p, plane_state);
1454
1455 for_each_new_crtc_in_state(state, crtc, crtc_state, i)
1456 drm_atomic_crtc_print_state(&p, crtc_state);
1457
1458 for_each_new_connector_in_state(state, connector, connector_state, i)
1459 drm_atomic_connector_print_state(&p, connector_state);
1460 }
1461
__drm_state_dump(struct drm_device * dev,struct drm_printer * p,bool take_locks)1462 static void __drm_state_dump(struct drm_device *dev, struct drm_printer *p,
1463 bool take_locks)
1464 {
1465 struct drm_mode_config *config = &dev->mode_config;
1466 struct drm_plane *plane;
1467 struct drm_crtc *crtc;
1468 struct drm_connector *connector;
1469 struct drm_connector_list_iter conn_iter;
1470
1471 if (!drm_drv_uses_atomic_modeset(dev))
1472 return;
1473
1474 list_for_each_entry(plane, &config->plane_list, head) {
1475 if (take_locks)
1476 drm_modeset_lock(&plane->mutex, NULL);
1477 drm_atomic_plane_print_state(p, plane->state);
1478 if (take_locks)
1479 drm_modeset_unlock(&plane->mutex);
1480 }
1481
1482 list_for_each_entry(crtc, &config->crtc_list, head) {
1483 if (take_locks)
1484 drm_modeset_lock(&crtc->mutex, NULL);
1485 drm_atomic_crtc_print_state(p, crtc->state);
1486 if (take_locks)
1487 drm_modeset_unlock(&crtc->mutex);
1488 }
1489
1490 drm_connector_list_iter_begin(dev, &conn_iter);
1491 if (take_locks)
1492 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
1493 drm_for_each_connector_iter(connector, &conn_iter)
1494 drm_atomic_connector_print_state(p, connector->state);
1495 if (take_locks)
1496 drm_modeset_unlock(&dev->mode_config.connection_mutex);
1497 drm_connector_list_iter_end(&conn_iter);
1498 }
1499
1500 /**
1501 * drm_state_dump - dump entire device atomic state
1502 * @dev: the drm device
1503 * @p: where to print the state to
1504 *
1505 * Just for debugging. Drivers might want an option to dump state
1506 * to dmesg in case of error irq's. (Hint, you probably want to
1507 * ratelimit this!)
1508 *
1509 * The caller must drm_modeset_lock_all(), or if this is called
1510 * from error irq handler, it should not be enabled by default.
1511 * (Ie. if you are debugging errors you might not care that this
1512 * is racey. But calling this without all modeset locks held is
1513 * not inherently safe.)
1514 */
drm_state_dump(struct drm_device * dev,struct drm_printer * p)1515 void drm_state_dump(struct drm_device *dev, struct drm_printer *p)
1516 {
1517 __drm_state_dump(dev, p, false);
1518 }
1519 EXPORT_SYMBOL(drm_state_dump);
1520
1521 #ifdef CONFIG_DEBUG_FS
drm_state_info(struct seq_file * m,void * data)1522 static int drm_state_info(struct seq_file *m, void *data)
1523 {
1524 struct drm_info_node *node = (struct drm_info_node *) m->private;
1525 struct drm_device *dev = node->minor->dev;
1526 struct drm_printer p = drm_seq_file_printer(m);
1527
1528 __drm_state_dump(dev, &p, true);
1529
1530 return 0;
1531 }
1532
1533 /* any use in debugfs files to dump individual planes/crtc/etc? */
1534 static const struct drm_info_list drm_atomic_debugfs_list[] = {
1535 {"state", drm_state_info, 0},
1536 };
1537
drm_atomic_debugfs_init(struct drm_minor * minor)1538 int drm_atomic_debugfs_init(struct drm_minor *minor)
1539 {
1540 return drm_debugfs_create_files(drm_atomic_debugfs_list,
1541 ARRAY_SIZE(drm_atomic_debugfs_list),
1542 minor->debugfs_root, minor);
1543 }
1544 #endif
1545