1 /*
2 * Copyright (c) 2006-2008 Intel Corporation
3 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
4 *
5 * DRM core CRTC related functions
6 *
7 * Permission to use, copy, modify, distribute, and sell this software and its
8 * documentation for any purpose is hereby granted without fee, provided that
9 * the above copyright notice appear in all copies and that both that copyright
10 * notice and this permission notice appear in supporting documentation, and
11 * that the name of the copyright holders not be used in advertising or
12 * publicity pertaining to distribution of the software without specific,
13 * written prior permission. The copyright holders make no representations
14 * about the suitability of this software for any purpose. It is provided "as
15 * is" without express or implied warranty.
16 *
17 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
18 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
19 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
20 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
22 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
23 * OF THIS SOFTWARE.
24 *
25 * Authors:
26 * Keith Packard
27 * Eric Anholt <eric@anholt.net>
28 * Dave Airlie <airlied@linux.ie>
29 * Jesse Barnes <jesse.barnes@intel.com>
30 */
31
32 #include <linux/kernel.h>
33 #include <linux/export.h>
34 #include <linux/moduleparam.h>
35
36 #include <drm/drmP.h>
37 #include <drm/drm_atomic.h>
38 #include <drm/drm_crtc.h>
39 #include <drm/drm_fourcc.h>
40 #include <drm/drm_crtc_helper.h>
41 #include <drm/drm_fb_helper.h>
42 #include <drm/drm_plane_helper.h>
43 #include <drm/drm_atomic_helper.h>
44 #include <drm/drm_edid.h>
45
46 /**
47 * DOC: overview
48 *
49 * The CRTC modeset helper library provides a default set_config implementation
50 * in drm_crtc_helper_set_config(). Plus a few other convenience functions using
51 * the same callbacks which drivers can use to e.g. restore the modeset
52 * configuration on resume with drm_helper_resume_force_mode().
53 *
54 * The driver callbacks are mostly compatible with the atomic modeset helpers,
55 * except for the handling of the primary plane: Atomic helpers require that the
56 * primary plane is implemented as a real standalone plane and not directly tied
57 * to the CRTC state. For easier transition this library provides functions to
58 * implement the old semantics required by the CRTC helpers using the new plane
59 * and atomic helper callbacks.
60 *
61 * Drivers are strongly urged to convert to the atomic helpers (by way of first
62 * converting to the plane helpers). New drivers must not use these functions
63 * but need to implement the atomic interface instead, potentially using the
64 * atomic helpers for that.
65 */
66 MODULE_AUTHOR("David Airlie, Jesse Barnes");
67 MODULE_DESCRIPTION("DRM KMS helper");
68 MODULE_LICENSE("GPL and additional rights");
69
70 /**
71 * drm_helper_move_panel_connectors_to_head() - move panels to the front in the
72 * connector list
73 * @dev: drm device to operate on
74 *
75 * Some userspace presumes that the first connected connector is the main
76 * display, where it's supposed to display e.g. the login screen. For
77 * laptops, this should be the main panel. Use this function to sort all
78 * (eDP/LVDS) panels to the front of the connector list, instead of
79 * painstakingly trying to initialize them in the right order.
80 */
drm_helper_move_panel_connectors_to_head(struct drm_device * dev)81 void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
82 {
83 struct drm_connector *connector, *tmp;
84 struct list_head panel_list;
85
86 INIT_LIST_HEAD(&panel_list);
87
88 list_for_each_entry_safe(connector, tmp,
89 &dev->mode_config.connector_list, head) {
90 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
91 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
92 list_move_tail(&connector->head, &panel_list);
93 }
94
95 list_splice(&panel_list, &dev->mode_config.connector_list);
96 }
97 EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
98
99 /**
100 * drm_helper_encoder_in_use - check if a given encoder is in use
101 * @encoder: encoder to check
102 *
103 * Checks whether @encoder is with the current mode setting output configuration
104 * in use by any connector. This doesn't mean that it is actually enabled since
105 * the DPMS state is tracked separately.
106 *
107 * Returns:
108 * True if @encoder is used, false otherwise.
109 */
drm_helper_encoder_in_use(struct drm_encoder * encoder)110 bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
111 {
112 struct drm_connector *connector;
113 struct drm_device *dev = encoder->dev;
114
115 /*
116 * We can expect this mutex to be locked if we are not panicking.
117 * Locking is currently fubar in the panic handler.
118 */
119 if (!oops_in_progress) {
120 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
121 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
122 }
123
124 drm_for_each_connector(connector, dev)
125 if (connector->encoder == encoder)
126 return true;
127 return false;
128 }
129 EXPORT_SYMBOL(drm_helper_encoder_in_use);
130
131 /**
132 * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
133 * @crtc: CRTC to check
134 *
135 * Checks whether @crtc is with the current mode setting output configuration
136 * in use by any connector. This doesn't mean that it is actually enabled since
137 * the DPMS state is tracked separately.
138 *
139 * Returns:
140 * True if @crtc is used, false otherwise.
141 */
drm_helper_crtc_in_use(struct drm_crtc * crtc)142 bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
143 {
144 struct drm_encoder *encoder;
145 struct drm_device *dev = crtc->dev;
146
147 /*
148 * We can expect this mutex to be locked if we are not panicking.
149 * Locking is currently fubar in the panic handler.
150 */
151 if (!oops_in_progress)
152 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
153
154 drm_for_each_encoder(encoder, dev)
155 if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
156 return true;
157 return false;
158 }
159 EXPORT_SYMBOL(drm_helper_crtc_in_use);
160
161 static void
drm_encoder_disable(struct drm_encoder * encoder)162 drm_encoder_disable(struct drm_encoder *encoder)
163 {
164 const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
165
166 drm_bridge_disable(encoder->bridge);
167
168 if (encoder_funcs->disable)
169 (*encoder_funcs->disable)(encoder);
170 else
171 (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
172
173 drm_bridge_post_disable(encoder->bridge);
174 }
175
__drm_helper_disable_unused_functions(struct drm_device * dev)176 static void __drm_helper_disable_unused_functions(struct drm_device *dev)
177 {
178 struct drm_encoder *encoder;
179 struct drm_crtc *crtc;
180
181 drm_warn_on_modeset_not_all_locked(dev);
182
183 drm_for_each_encoder(encoder, dev) {
184 if (!drm_helper_encoder_in_use(encoder)) {
185 drm_encoder_disable(encoder);
186 /* disconnect encoder from any connector */
187 encoder->crtc = NULL;
188 }
189 }
190
191 drm_for_each_crtc(crtc, dev) {
192 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
193 crtc->enabled = drm_helper_crtc_in_use(crtc);
194 if (!crtc->enabled) {
195 if (crtc_funcs->disable)
196 (*crtc_funcs->disable)(crtc);
197 else
198 (*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
199 crtc->primary->fb = NULL;
200 }
201 }
202 }
203
204 /**
205 * drm_helper_disable_unused_functions - disable unused objects
206 * @dev: DRM device
207 *
208 * This function walks through the entire mode setting configuration of @dev. It
209 * will remove any crtc links of unused encoders and encoder links of
210 * disconnected connectors. Then it will disable all unused encoders and crtcs
211 * either by calling their disable callback if available or by calling their
212 * dpms callback with DRM_MODE_DPMS_OFF.
213 */
drm_helper_disable_unused_functions(struct drm_device * dev)214 void drm_helper_disable_unused_functions(struct drm_device *dev)
215 {
216 drm_modeset_lock_all(dev);
217 __drm_helper_disable_unused_functions(dev);
218 drm_modeset_unlock_all(dev);
219 }
220 EXPORT_SYMBOL(drm_helper_disable_unused_functions);
221
222 /*
223 * Check the CRTC we're going to map each output to vs. its current
224 * CRTC. If they don't match, we have to disable the output and the CRTC
225 * since the driver will have to re-route things.
226 */
227 static void
drm_crtc_prepare_encoders(struct drm_device * dev)228 drm_crtc_prepare_encoders(struct drm_device *dev)
229 {
230 const struct drm_encoder_helper_funcs *encoder_funcs;
231 struct drm_encoder *encoder;
232
233 drm_for_each_encoder(encoder, dev) {
234 encoder_funcs = encoder->helper_private;
235 /* Disable unused encoders */
236 if (encoder->crtc == NULL)
237 drm_encoder_disable(encoder);
238 /* Disable encoders whose CRTC is about to change */
239 if (encoder_funcs->get_crtc &&
240 encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
241 drm_encoder_disable(encoder);
242 }
243 }
244
245 /**
246 * drm_crtc_helper_set_mode - internal helper to set a mode
247 * @crtc: CRTC to program
248 * @mode: mode to use
249 * @x: horizontal offset into the surface
250 * @y: vertical offset into the surface
251 * @old_fb: old framebuffer, for cleanup
252 *
253 * Try to set @mode on @crtc. Give @crtc and its associated connectors a chance
254 * to fixup or reject the mode prior to trying to set it. This is an internal
255 * helper that drivers could e.g. use to update properties that require the
256 * entire output pipe to be disabled and re-enabled in a new configuration. For
257 * example for changing whether audio is enabled on a hdmi link or for changing
258 * panel fitter or dither attributes. It is also called by the
259 * drm_crtc_helper_set_config() helper function to drive the mode setting
260 * sequence.
261 *
262 * Returns:
263 * True if the mode was set successfully, false otherwise.
264 */
drm_crtc_helper_set_mode(struct drm_crtc * crtc,struct drm_display_mode * mode,int x,int y,struct drm_framebuffer * old_fb)265 bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
266 struct drm_display_mode *mode,
267 int x, int y,
268 struct drm_framebuffer *old_fb)
269 {
270 struct drm_device *dev = crtc->dev;
271 struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
272 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
273 const struct drm_encoder_helper_funcs *encoder_funcs;
274 int saved_x, saved_y;
275 bool saved_enabled;
276 struct drm_encoder *encoder;
277 bool ret = true;
278
279 drm_warn_on_modeset_not_all_locked(dev);
280
281 saved_enabled = crtc->enabled;
282 crtc->enabled = drm_helper_crtc_in_use(crtc);
283 if (!crtc->enabled)
284 return true;
285
286 adjusted_mode = drm_mode_duplicate(dev, mode);
287 if (!adjusted_mode) {
288 crtc->enabled = saved_enabled;
289 return false;
290 }
291
292 saved_mode = crtc->mode;
293 saved_hwmode = crtc->hwmode;
294 saved_x = crtc->x;
295 saved_y = crtc->y;
296
297 /* Update crtc values up front so the driver can rely on them for mode
298 * setting.
299 */
300 crtc->mode = *mode;
301 crtc->x = x;
302 crtc->y = y;
303
304 /* Pass our mode to the connectors and the CRTC to give them a chance to
305 * adjust it according to limitations or connector properties, and also
306 * a chance to reject the mode entirely.
307 */
308 drm_for_each_encoder(encoder, dev) {
309
310 if (encoder->crtc != crtc)
311 continue;
312
313 ret = drm_bridge_mode_fixup(encoder->bridge,
314 mode, adjusted_mode);
315 if (!ret) {
316 DRM_DEBUG_KMS("Bridge fixup failed\n");
317 goto done;
318 }
319
320 encoder_funcs = encoder->helper_private;
321 if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
322 adjusted_mode))) {
323 DRM_DEBUG_KMS("Encoder fixup failed\n");
324 goto done;
325 }
326 }
327
328 if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
329 DRM_DEBUG_KMS("CRTC fixup failed\n");
330 goto done;
331 }
332 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
333
334 crtc->hwmode = *adjusted_mode;
335
336 /* Prepare the encoders and CRTCs before setting the mode. */
337 drm_for_each_encoder(encoder, dev) {
338
339 if (encoder->crtc != crtc)
340 continue;
341
342 drm_bridge_disable(encoder->bridge);
343
344 encoder_funcs = encoder->helper_private;
345 /* Disable the encoders as the first thing we do. */
346 encoder_funcs->prepare(encoder);
347
348 drm_bridge_post_disable(encoder->bridge);
349 }
350
351 drm_crtc_prepare_encoders(dev);
352
353 crtc_funcs->prepare(crtc);
354
355 /* Set up the DPLL and any encoders state that needs to adjust or depend
356 * on the DPLL.
357 */
358 ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
359 if (!ret)
360 goto done;
361
362 drm_for_each_encoder(encoder, dev) {
363
364 if (encoder->crtc != crtc)
365 continue;
366
367 DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
368 encoder->base.id, encoder->name,
369 mode->base.id, mode->name);
370 encoder_funcs = encoder->helper_private;
371 encoder_funcs->mode_set(encoder, mode, adjusted_mode);
372
373 drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
374 }
375
376 /* Now enable the clocks, plane, pipe, and connectors that we set up. */
377 crtc_funcs->commit(crtc);
378
379 drm_for_each_encoder(encoder, dev) {
380
381 if (encoder->crtc != crtc)
382 continue;
383
384 drm_bridge_pre_enable(encoder->bridge);
385
386 encoder_funcs = encoder->helper_private;
387 encoder_funcs->commit(encoder);
388
389 drm_bridge_enable(encoder->bridge);
390 }
391
392 /* Calculate and store various constants which
393 * are later needed by vblank and swap-completion
394 * timestamping. They are derived from true hwmode.
395 */
396 drm_calc_timestamping_constants(crtc, &crtc->hwmode);
397
398 /* FIXME: add subpixel order */
399 done:
400 drm_mode_destroy(dev, adjusted_mode);
401 if (!ret) {
402 crtc->enabled = saved_enabled;
403 crtc->mode = saved_mode;
404 crtc->hwmode = saved_hwmode;
405 crtc->x = saved_x;
406 crtc->y = saved_y;
407 }
408
409 return ret;
410 }
411 EXPORT_SYMBOL(drm_crtc_helper_set_mode);
412
413 static void
drm_crtc_helper_disable(struct drm_crtc * crtc)414 drm_crtc_helper_disable(struct drm_crtc *crtc)
415 {
416 struct drm_device *dev = crtc->dev;
417 struct drm_connector *connector;
418 struct drm_encoder *encoder;
419
420 /* Decouple all encoders and their attached connectors from this crtc */
421 drm_for_each_encoder(encoder, dev) {
422 if (encoder->crtc != crtc)
423 continue;
424
425 drm_for_each_connector(connector, dev) {
426 if (connector->encoder != encoder)
427 continue;
428
429 connector->encoder = NULL;
430
431 /*
432 * drm_helper_disable_unused_functions() ought to be
433 * doing this, but since we've decoupled the encoder
434 * from the connector above, the required connection
435 * between them is henceforth no longer available.
436 */
437 connector->dpms = DRM_MODE_DPMS_OFF;
438 }
439 }
440
441 __drm_helper_disable_unused_functions(dev);
442 }
443
444 /**
445 * drm_crtc_helper_set_config - set a new config from userspace
446 * @set: mode set configuration
447 *
448 * Setup a new configuration, provided by the upper layers (either an ioctl call
449 * from userspace or internally e.g. from the fbdev support code) in @set, and
450 * enable it. This is the main helper functions for drivers that implement
451 * kernel mode setting with the crtc helper functions and the assorted
452 * ->prepare(), ->modeset() and ->commit() helper callbacks.
453 *
454 * Returns:
455 * Returns 0 on success, negative errno numbers on failure.
456 */
drm_crtc_helper_set_config(struct drm_mode_set * set)457 int drm_crtc_helper_set_config(struct drm_mode_set *set)
458 {
459 struct drm_device *dev;
460 struct drm_crtc *new_crtc;
461 struct drm_encoder *save_encoders, *new_encoder, *encoder;
462 bool mode_changed = false; /* if true do a full mode set */
463 bool fb_changed = false; /* if true and !mode_changed just do a flip */
464 struct drm_connector *save_connectors, *connector;
465 int count = 0, ro, fail = 0;
466 const struct drm_crtc_helper_funcs *crtc_funcs;
467 struct drm_mode_set save_set;
468 int ret;
469 int i;
470
471 DRM_DEBUG_KMS("\n");
472
473 BUG_ON(!set);
474 BUG_ON(!set->crtc);
475 BUG_ON(!set->crtc->helper_private);
476
477 /* Enforce sane interface api - has been abused by the fb helper. */
478 BUG_ON(!set->mode && set->fb);
479 BUG_ON(set->fb && set->num_connectors == 0);
480
481 crtc_funcs = set->crtc->helper_private;
482
483 if (!set->mode)
484 set->fb = NULL;
485
486 if (set->fb) {
487 DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
488 set->crtc->base.id, set->fb->base.id,
489 (int)set->num_connectors, set->x, set->y);
490 } else {
491 DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
492 drm_crtc_helper_disable(set->crtc);
493 return 0;
494 }
495
496 dev = set->crtc->dev;
497
498 drm_warn_on_modeset_not_all_locked(dev);
499
500 /*
501 * Allocate space for the backup of all (non-pointer) encoder and
502 * connector data.
503 */
504 save_encoders = kzalloc(dev->mode_config.num_encoder *
505 sizeof(struct drm_encoder), GFP_KERNEL);
506 if (!save_encoders)
507 return -ENOMEM;
508
509 save_connectors = kzalloc(dev->mode_config.num_connector *
510 sizeof(struct drm_connector), GFP_KERNEL);
511 if (!save_connectors) {
512 kfree(save_encoders);
513 return -ENOMEM;
514 }
515
516 /*
517 * Copy data. Note that driver private data is not affected.
518 * Should anything bad happen only the expected state is
519 * restored, not the drivers personal bookkeeping.
520 */
521 count = 0;
522 drm_for_each_encoder(encoder, dev) {
523 save_encoders[count++] = *encoder;
524 }
525
526 count = 0;
527 drm_for_each_connector(connector, dev) {
528 save_connectors[count++] = *connector;
529 }
530
531 save_set.crtc = set->crtc;
532 save_set.mode = &set->crtc->mode;
533 save_set.x = set->crtc->x;
534 save_set.y = set->crtc->y;
535 save_set.fb = set->crtc->primary->fb;
536
537 /* We should be able to check here if the fb has the same properties
538 * and then just flip_or_move it */
539 if (set->crtc->primary->fb != set->fb) {
540 /* If we have no fb then treat it as a full mode set */
541 if (set->crtc->primary->fb == NULL) {
542 DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
543 mode_changed = true;
544 } else if (set->fb == NULL) {
545 mode_changed = true;
546 } else if (set->fb->pixel_format !=
547 set->crtc->primary->fb->pixel_format) {
548 mode_changed = true;
549 } else
550 fb_changed = true;
551 }
552
553 if (set->x != set->crtc->x || set->y != set->crtc->y)
554 fb_changed = true;
555
556 if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
557 DRM_DEBUG_KMS("modes are different, full mode set\n");
558 drm_mode_debug_printmodeline(&set->crtc->mode);
559 drm_mode_debug_printmodeline(set->mode);
560 mode_changed = true;
561 }
562
563 /* a) traverse passed in connector list and get encoders for them */
564 count = 0;
565 drm_for_each_connector(connector, dev) {
566 const struct drm_connector_helper_funcs *connector_funcs =
567 connector->helper_private;
568 new_encoder = connector->encoder;
569 for (ro = 0; ro < set->num_connectors; ro++) {
570 if (set->connectors[ro] == connector) {
571 new_encoder = connector_funcs->best_encoder(connector);
572 /* if we can't get an encoder for a connector
573 we are setting now - then fail */
574 if (new_encoder == NULL)
575 /* don't break so fail path works correct */
576 fail = 1;
577
578 if (connector->dpms != DRM_MODE_DPMS_ON) {
579 DRM_DEBUG_KMS("connector dpms not on, full mode switch\n");
580 mode_changed = true;
581 }
582
583 break;
584 }
585 }
586
587 if (new_encoder != connector->encoder) {
588 DRM_DEBUG_KMS("encoder changed, full mode switch\n");
589 mode_changed = true;
590 /* If the encoder is reused for another connector, then
591 * the appropriate crtc will be set later.
592 */
593 if (connector->encoder)
594 connector->encoder->crtc = NULL;
595 connector->encoder = new_encoder;
596 }
597 }
598
599 if (fail) {
600 ret = -EINVAL;
601 goto fail;
602 }
603
604 count = 0;
605 drm_for_each_connector(connector, dev) {
606 if (!connector->encoder)
607 continue;
608
609 if (connector->encoder->crtc == set->crtc)
610 new_crtc = NULL;
611 else
612 new_crtc = connector->encoder->crtc;
613
614 for (ro = 0; ro < set->num_connectors; ro++) {
615 if (set->connectors[ro] == connector)
616 new_crtc = set->crtc;
617 }
618
619 /* Make sure the new CRTC will work with the encoder */
620 if (new_crtc &&
621 !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
622 ret = -EINVAL;
623 goto fail;
624 }
625 if (new_crtc != connector->encoder->crtc) {
626 DRM_DEBUG_KMS("crtc changed, full mode switch\n");
627 mode_changed = true;
628 connector->encoder->crtc = new_crtc;
629 }
630 if (new_crtc) {
631 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
632 connector->base.id, connector->name,
633 new_crtc->base.id);
634 } else {
635 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
636 connector->base.id, connector->name);
637 }
638 }
639
640 /* mode_set_base is not a required function */
641 if (fb_changed && !crtc_funcs->mode_set_base)
642 mode_changed = true;
643
644 if (mode_changed) {
645 if (drm_helper_crtc_in_use(set->crtc)) {
646 DRM_DEBUG_KMS("attempting to set mode from"
647 " userspace\n");
648 drm_mode_debug_printmodeline(set->mode);
649 set->crtc->primary->fb = set->fb;
650 if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
651 set->x, set->y,
652 save_set.fb)) {
653 DRM_ERROR("failed to set mode on [CRTC:%d]\n",
654 set->crtc->base.id);
655 set->crtc->primary->fb = save_set.fb;
656 ret = -EINVAL;
657 goto fail;
658 }
659 DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
660 for (i = 0; i < set->num_connectors; i++) {
661 DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
662 set->connectors[i]->name);
663 set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
664 }
665 }
666 __drm_helper_disable_unused_functions(dev);
667 } else if (fb_changed) {
668 set->crtc->x = set->x;
669 set->crtc->y = set->y;
670 set->crtc->primary->fb = set->fb;
671 ret = crtc_funcs->mode_set_base(set->crtc,
672 set->x, set->y, save_set.fb);
673 if (ret != 0) {
674 set->crtc->x = save_set.x;
675 set->crtc->y = save_set.y;
676 set->crtc->primary->fb = save_set.fb;
677 goto fail;
678 }
679 }
680
681 kfree(save_connectors);
682 kfree(save_encoders);
683 return 0;
684
685 fail:
686 /* Restore all previous data. */
687 count = 0;
688 drm_for_each_encoder(encoder, dev) {
689 *encoder = save_encoders[count++];
690 }
691
692 count = 0;
693 drm_for_each_connector(connector, dev) {
694 *connector = save_connectors[count++];
695 }
696
697 /* Try to restore the config */
698 if (mode_changed &&
699 !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
700 save_set.y, save_set.fb))
701 DRM_ERROR("failed to restore config after modeset failure\n");
702
703 kfree(save_connectors);
704 kfree(save_encoders);
705 return ret;
706 }
707 EXPORT_SYMBOL(drm_crtc_helper_set_config);
708
drm_helper_choose_encoder_dpms(struct drm_encoder * encoder)709 static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
710 {
711 int dpms = DRM_MODE_DPMS_OFF;
712 struct drm_connector *connector;
713 struct drm_device *dev = encoder->dev;
714
715 drm_for_each_connector(connector, dev)
716 if (connector->encoder == encoder)
717 if (connector->dpms < dpms)
718 dpms = connector->dpms;
719 return dpms;
720 }
721
722 /* Helper which handles bridge ordering around encoder dpms */
drm_helper_encoder_dpms(struct drm_encoder * encoder,int mode)723 static void drm_helper_encoder_dpms(struct drm_encoder *encoder, int mode)
724 {
725 struct drm_bridge *bridge = encoder->bridge;
726 const struct drm_encoder_helper_funcs *encoder_funcs;
727
728 if (mode == DRM_MODE_DPMS_ON)
729 drm_bridge_pre_enable(bridge);
730 else
731 drm_bridge_disable(bridge);
732
733 encoder_funcs = encoder->helper_private;
734 if (encoder_funcs->dpms)
735 encoder_funcs->dpms(encoder, mode);
736
737 if (mode == DRM_MODE_DPMS_ON)
738 drm_bridge_enable(bridge);
739 else
740 drm_bridge_post_disable(bridge);
741 }
742
drm_helper_choose_crtc_dpms(struct drm_crtc * crtc)743 static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
744 {
745 int dpms = DRM_MODE_DPMS_OFF;
746 struct drm_connector *connector;
747 struct drm_device *dev = crtc->dev;
748
749 drm_for_each_connector(connector, dev)
750 if (connector->encoder && connector->encoder->crtc == crtc)
751 if (connector->dpms < dpms)
752 dpms = connector->dpms;
753 return dpms;
754 }
755
756 /**
757 * drm_helper_connector_dpms() - connector dpms helper implementation
758 * @connector: affected connector
759 * @mode: DPMS mode
760 *
761 * This is the main helper function provided by the crtc helper framework for
762 * implementing the DPMS connector attribute. It computes the new desired DPMS
763 * state for all encoders and crtcs in the output mesh and calls the ->dpms()
764 * callback provided by the driver appropriately.
765 *
766 * Returns:
767 * Always returns 0.
768 */
drm_helper_connector_dpms(struct drm_connector * connector,int mode)769 int drm_helper_connector_dpms(struct drm_connector *connector, int mode)
770 {
771 struct drm_encoder *encoder = connector->encoder;
772 struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
773 int old_dpms, encoder_dpms = DRM_MODE_DPMS_OFF;
774
775 if (mode == connector->dpms)
776 return 0;
777
778 old_dpms = connector->dpms;
779 connector->dpms = mode;
780
781 if (encoder)
782 encoder_dpms = drm_helper_choose_encoder_dpms(encoder);
783
784 /* from off to on, do crtc then encoder */
785 if (mode < old_dpms) {
786 if (crtc) {
787 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
788 if (crtc_funcs->dpms)
789 (*crtc_funcs->dpms) (crtc,
790 drm_helper_choose_crtc_dpms(crtc));
791 }
792 if (encoder)
793 drm_helper_encoder_dpms(encoder, encoder_dpms);
794 }
795
796 /* from on to off, do encoder then crtc */
797 if (mode > old_dpms) {
798 if (encoder)
799 drm_helper_encoder_dpms(encoder, encoder_dpms);
800 if (crtc) {
801 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
802 if (crtc_funcs->dpms)
803 (*crtc_funcs->dpms) (crtc,
804 drm_helper_choose_crtc_dpms(crtc));
805 }
806 }
807
808 return 0;
809 }
810 EXPORT_SYMBOL(drm_helper_connector_dpms);
811
812 /**
813 * drm_helper_mode_fill_fb_struct - fill out framebuffer metadata
814 * @fb: drm_framebuffer object to fill out
815 * @mode_cmd: metadata from the userspace fb creation request
816 *
817 * This helper can be used in a drivers fb_create callback to pre-fill the fb's
818 * metadata fields.
819 */
drm_helper_mode_fill_fb_struct(struct drm_framebuffer * fb,struct drm_mode_fb_cmd2 * mode_cmd)820 void drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
821 struct drm_mode_fb_cmd2 *mode_cmd)
822 {
823 int i;
824
825 fb->width = mode_cmd->width;
826 fb->height = mode_cmd->height;
827 for (i = 0; i < 4; i++) {
828 fb->pitches[i] = mode_cmd->pitches[i];
829 fb->offsets[i] = mode_cmd->offsets[i];
830 fb->modifier[i] = mode_cmd->modifier[i];
831 }
832 drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
833 &fb->bits_per_pixel);
834 fb->pixel_format = mode_cmd->pixel_format;
835 fb->flags = mode_cmd->flags;
836 }
837 EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
838
839 /**
840 * drm_helper_resume_force_mode - force-restore mode setting configuration
841 * @dev: drm_device which should be restored
842 *
843 * Drivers which use the mode setting helpers can use this function to
844 * force-restore the mode setting configuration e.g. on resume or when something
845 * else might have trampled over the hw state (like some overzealous old BIOSen
846 * tended to do).
847 *
848 * This helper doesn't provide a error return value since restoring the old
849 * config should never fail due to resource allocation issues since the driver
850 * has successfully set the restored configuration already. Hence this should
851 * boil down to the equivalent of a few dpms on calls, which also don't provide
852 * an error code.
853 *
854 * Drivers where simply restoring an old configuration again might fail (e.g.
855 * due to slight differences in allocating shared resources when the
856 * configuration is restored in a different order than when userspace set it up)
857 * need to use their own restore logic.
858 */
drm_helper_resume_force_mode(struct drm_device * dev)859 void drm_helper_resume_force_mode(struct drm_device *dev)
860 {
861 struct drm_crtc *crtc;
862 struct drm_encoder *encoder;
863 const struct drm_crtc_helper_funcs *crtc_funcs;
864 int encoder_dpms;
865 bool ret;
866
867 drm_modeset_lock_all(dev);
868 drm_for_each_crtc(crtc, dev) {
869
870 if (!crtc->enabled)
871 continue;
872
873 ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
874 crtc->x, crtc->y, crtc->primary->fb);
875
876 /* Restoring the old config should never fail! */
877 if (ret == false)
878 DRM_ERROR("failed to set mode on crtc %p\n", crtc);
879
880 /* Turn off outputs that were already powered off */
881 if (drm_helper_choose_crtc_dpms(crtc)) {
882 drm_for_each_encoder(encoder, dev) {
883
884 if(encoder->crtc != crtc)
885 continue;
886
887 encoder_dpms = drm_helper_choose_encoder_dpms(
888 encoder);
889
890 drm_helper_encoder_dpms(encoder, encoder_dpms);
891 }
892
893 crtc_funcs = crtc->helper_private;
894 if (crtc_funcs->dpms)
895 (*crtc_funcs->dpms) (crtc,
896 drm_helper_choose_crtc_dpms(crtc));
897 }
898 }
899
900 /* disable the unused connectors while restoring the modesetting */
901 __drm_helper_disable_unused_functions(dev);
902 drm_modeset_unlock_all(dev);
903 }
904 EXPORT_SYMBOL(drm_helper_resume_force_mode);
905
906 /**
907 * drm_helper_crtc_mode_set - mode_set implementation for atomic plane helpers
908 * @crtc: DRM CRTC
909 * @mode: DRM display mode which userspace requested
910 * @adjusted_mode: DRM display mode adjusted by ->mode_fixup callbacks
911 * @x: x offset of the CRTC scanout area on the underlying framebuffer
912 * @y: y offset of the CRTC scanout area on the underlying framebuffer
913 * @old_fb: previous framebuffer
914 *
915 * This function implements a callback useable as the ->mode_set callback
916 * required by the crtc helpers. Besides the atomic plane helper functions for
917 * the primary plane the driver must also provide the ->mode_set_nofb callback
918 * to set up the crtc.
919 *
920 * This is a transitional helper useful for converting drivers to the atomic
921 * interfaces.
922 */
drm_helper_crtc_mode_set(struct drm_crtc * crtc,struct drm_display_mode * mode,struct drm_display_mode * adjusted_mode,int x,int y,struct drm_framebuffer * old_fb)923 int drm_helper_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
924 struct drm_display_mode *adjusted_mode, int x, int y,
925 struct drm_framebuffer *old_fb)
926 {
927 struct drm_crtc_state *crtc_state;
928 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
929 int ret;
930
931 if (crtc->funcs->atomic_duplicate_state)
932 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
933 else {
934 if (!crtc->state)
935 drm_atomic_helper_crtc_reset(crtc);
936
937 crtc_state = drm_atomic_helper_crtc_duplicate_state(crtc);
938 }
939
940 if (!crtc_state)
941 return -ENOMEM;
942
943 crtc_state->planes_changed = true;
944 crtc_state->mode_changed = true;
945 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
946 if (ret)
947 goto out;
948 drm_mode_copy(&crtc_state->adjusted_mode, adjusted_mode);
949
950 if (crtc_funcs->atomic_check) {
951 ret = crtc_funcs->atomic_check(crtc, crtc_state);
952 if (ret)
953 goto out;
954 }
955
956 swap(crtc->state, crtc_state);
957
958 crtc_funcs->mode_set_nofb(crtc);
959
960 ret = drm_helper_crtc_mode_set_base(crtc, x, y, old_fb);
961
962 out:
963 if (crtc_state) {
964 if (crtc->funcs->atomic_destroy_state)
965 crtc->funcs->atomic_destroy_state(crtc, crtc_state);
966 else
967 drm_atomic_helper_crtc_destroy_state(crtc, crtc_state);
968 }
969
970 return ret;
971 }
972 EXPORT_SYMBOL(drm_helper_crtc_mode_set);
973
974 /**
975 * drm_helper_crtc_mode_set_base - mode_set_base implementation for atomic plane helpers
976 * @crtc: DRM CRTC
977 * @x: x offset of the CRTC scanout area on the underlying framebuffer
978 * @y: y offset of the CRTC scanout area on the underlying framebuffer
979 * @old_fb: previous framebuffer
980 *
981 * This function implements a callback useable as the ->mode_set_base used
982 * required by the crtc helpers. The driver must provide the atomic plane helper
983 * functions for the primary plane.
984 *
985 * This is a transitional helper useful for converting drivers to the atomic
986 * interfaces.
987 */
drm_helper_crtc_mode_set_base(struct drm_crtc * crtc,int x,int y,struct drm_framebuffer * old_fb)988 int drm_helper_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
989 struct drm_framebuffer *old_fb)
990 {
991 struct drm_plane_state *plane_state;
992 struct drm_plane *plane = crtc->primary;
993
994 if (plane->funcs->atomic_duplicate_state)
995 plane_state = plane->funcs->atomic_duplicate_state(plane);
996 else if (plane->state)
997 plane_state = drm_atomic_helper_plane_duplicate_state(plane);
998 else
999 plane_state = kzalloc(sizeof(*plane_state), GFP_KERNEL);
1000 if (!plane_state)
1001 return -ENOMEM;
1002 plane_state->plane = plane;
1003
1004 plane_state->crtc = crtc;
1005 drm_atomic_set_fb_for_plane(plane_state, crtc->primary->fb);
1006 plane_state->crtc_x = 0;
1007 plane_state->crtc_y = 0;
1008 plane_state->crtc_h = crtc->mode.vdisplay;
1009 plane_state->crtc_w = crtc->mode.hdisplay;
1010 plane_state->src_x = x << 16;
1011 plane_state->src_y = y << 16;
1012 plane_state->src_h = crtc->mode.vdisplay << 16;
1013 plane_state->src_w = crtc->mode.hdisplay << 16;
1014
1015 return drm_plane_helper_commit(plane, plane_state, old_fb);
1016 }
1017 EXPORT_SYMBOL(drm_helper_crtc_mode_set_base);
1018