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/export.h>
33 #include <linux/moduleparam.h>
34
35 #include <drm/drmP.h>
36 #include <drm/drm_crtc.h>
37 #include <drm/drm_fourcc.h>
38 #include <drm/drm_crtc_helper.h>
39 #include <drm/drm_fb_helper.h>
40 #include <drm/drm_edid.h>
41
42 /**
43 * drm_helper_move_panel_connectors_to_head() - move panels to the front in the
44 * connector list
45 * @dev: drm device to operate on
46 *
47 * Some userspace presumes that the first connected connector is the main
48 * display, where it's supposed to display e.g. the login screen. For
49 * laptops, this should be the main panel. Use this function to sort all
50 * (eDP/LVDS) panels to the front of the connector list, instead of
51 * painstakingly trying to initialize them in the right order.
52 */
drm_helper_move_panel_connectors_to_head(struct drm_device * dev)53 void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
54 {
55 struct drm_connector *connector, *tmp;
56 struct list_head panel_list;
57
58 INIT_LIST_HEAD(&panel_list);
59
60 list_for_each_entry_safe(connector, tmp,
61 &dev->mode_config.connector_list, head) {
62 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
63 connector->connector_type == DRM_MODE_CONNECTOR_eDP)
64 list_move_tail(&connector->head, &panel_list);
65 }
66
67 list_splice(&panel_list, &dev->mode_config.connector_list);
68 }
69 EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
70
71 static bool drm_kms_helper_poll = true;
72 module_param_named(poll, drm_kms_helper_poll, bool, 0600);
73
drm_mode_validate_flag(struct drm_connector * connector,int flags)74 static void drm_mode_validate_flag(struct drm_connector *connector,
75 int flags)
76 {
77 struct drm_display_mode *mode;
78
79 if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE))
80 return;
81
82 list_for_each_entry(mode, &connector->modes, head) {
83 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
84 !(flags & DRM_MODE_FLAG_INTERLACE))
85 mode->status = MODE_NO_INTERLACE;
86 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
87 !(flags & DRM_MODE_FLAG_DBLSCAN))
88 mode->status = MODE_NO_DBLESCAN;
89 }
90
91 return;
92 }
93
94 /**
95 * drm_helper_probe_single_connector_modes - get complete set of display modes
96 * @connector: connector to probe
97 * @maxX: max width for modes
98 * @maxY: max height for modes
99 *
100 * LOCKING:
101 * Caller must hold mode config lock.
102 *
103 * Based on the helper callbacks implemented by @connector try to detect all
104 * valid modes. Modes will first be added to the connector's probed_modes list,
105 * then culled (based on validity and the @maxX, @maxY parameters) and put into
106 * the normal modes list.
107 *
108 * Intended to be use as a generic implementation of the ->probe() @connector
109 * callback for drivers that use the crtc helpers for output mode filtering and
110 * detection.
111 *
112 * RETURNS:
113 * Number of modes found on @connector.
114 */
drm_helper_probe_single_connector_modes(struct drm_connector * connector,uint32_t maxX,uint32_t maxY)115 int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
116 uint32_t maxX, uint32_t maxY)
117 {
118 struct drm_device *dev = connector->dev;
119 struct drm_display_mode *mode;
120 struct drm_connector_helper_funcs *connector_funcs =
121 connector->helper_private;
122 int count = 0;
123 int mode_flags = 0;
124 bool verbose_prune = true;
125
126 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
127 drm_get_connector_name(connector));
128 /* set all modes to the unverified state */
129 list_for_each_entry(mode, &connector->modes, head)
130 mode->status = MODE_UNVERIFIED;
131
132 if (connector->force) {
133 if (connector->force == DRM_FORCE_ON)
134 connector->status = connector_status_connected;
135 else
136 connector->status = connector_status_disconnected;
137 if (connector->funcs->force)
138 connector->funcs->force(connector);
139 } else {
140 connector->status = connector->funcs->detect(connector, true);
141 }
142
143 /* Re-enable polling in case the global poll config changed. */
144 if (drm_kms_helper_poll != dev->mode_config.poll_running)
145 drm_kms_helper_poll_enable(dev);
146
147 dev->mode_config.poll_running = drm_kms_helper_poll;
148
149 if (connector->status == connector_status_disconnected) {
150 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
151 connector->base.id, drm_get_connector_name(connector));
152 drm_mode_connector_update_edid_property(connector, NULL);
153 verbose_prune = false;
154 goto prune;
155 }
156
157 #ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE
158 count = drm_load_edid_firmware(connector);
159 if (count == 0)
160 #endif
161 count = (*connector_funcs->get_modes)(connector);
162
163 if (count == 0 && connector->status == connector_status_connected)
164 count = drm_add_modes_noedid(connector, 1024, 768);
165 if (count == 0)
166 goto prune;
167
168 drm_mode_connector_list_update(connector);
169
170 if (maxX && maxY)
171 drm_mode_validate_size(dev, &connector->modes, maxX,
172 maxY, 0);
173
174 if (connector->interlace_allowed)
175 mode_flags |= DRM_MODE_FLAG_INTERLACE;
176 if (connector->doublescan_allowed)
177 mode_flags |= DRM_MODE_FLAG_DBLSCAN;
178 drm_mode_validate_flag(connector, mode_flags);
179
180 list_for_each_entry(mode, &connector->modes, head) {
181 if (mode->status == MODE_OK)
182 mode->status = connector_funcs->mode_valid(connector,
183 mode);
184 }
185
186 prune:
187 drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);
188
189 if (list_empty(&connector->modes))
190 return 0;
191
192 drm_mode_sort(&connector->modes);
193
194 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
195 drm_get_connector_name(connector));
196 list_for_each_entry(mode, &connector->modes, head) {
197 mode->vrefresh = drm_mode_vrefresh(mode);
198
199 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
200 drm_mode_debug_printmodeline(mode);
201 }
202
203 return count;
204 }
205 EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
206
207 /**
208 * drm_helper_encoder_in_use - check if a given encoder is in use
209 * @encoder: encoder to check
210 *
211 * LOCKING:
212 * Caller must hold mode config lock.
213 *
214 * Walk @encoders's DRM device's mode_config and see if it's in use.
215 *
216 * RETURNS:
217 * True if @encoder is part of the mode_config, false otherwise.
218 */
drm_helper_encoder_in_use(struct drm_encoder * encoder)219 bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
220 {
221 struct drm_connector *connector;
222 struct drm_device *dev = encoder->dev;
223 list_for_each_entry(connector, &dev->mode_config.connector_list, head)
224 if (connector->encoder == encoder)
225 return true;
226 return false;
227 }
228 EXPORT_SYMBOL(drm_helper_encoder_in_use);
229
230 /**
231 * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
232 * @crtc: CRTC to check
233 *
234 * LOCKING:
235 * Caller must hold mode config lock.
236 *
237 * Walk @crtc's DRM device's mode_config and see if it's in use.
238 *
239 * RETURNS:
240 * True if @crtc is part of the mode_config, false otherwise.
241 */
drm_helper_crtc_in_use(struct drm_crtc * crtc)242 bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
243 {
244 struct drm_encoder *encoder;
245 struct drm_device *dev = crtc->dev;
246 /* FIXME: Locking around list access? */
247 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
248 if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
249 return true;
250 return false;
251 }
252 EXPORT_SYMBOL(drm_helper_crtc_in_use);
253
254 static void
drm_encoder_disable(struct drm_encoder * encoder)255 drm_encoder_disable(struct drm_encoder *encoder)
256 {
257 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
258
259 if (encoder_funcs->disable)
260 (*encoder_funcs->disable)(encoder);
261 else
262 (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
263 }
264
265 /**
266 * drm_helper_disable_unused_functions - disable unused objects
267 * @dev: DRM device
268 *
269 * LOCKING:
270 * Caller must hold mode config lock.
271 *
272 * If an connector or CRTC isn't part of @dev's mode_config, it can be disabled
273 * by calling its dpms function, which should power it off.
274 */
drm_helper_disable_unused_functions(struct drm_device * dev)275 void drm_helper_disable_unused_functions(struct drm_device *dev)
276 {
277 struct drm_encoder *encoder;
278 struct drm_connector *connector;
279 struct drm_crtc *crtc;
280
281 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
282 if (!connector->encoder)
283 continue;
284 if (connector->status == connector_status_disconnected)
285 connector->encoder = NULL;
286 }
287
288 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
289 if (!drm_helper_encoder_in_use(encoder)) {
290 drm_encoder_disable(encoder);
291 /* disconnector encoder from any connector */
292 encoder->crtc = NULL;
293 }
294 }
295
296 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
297 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
298 crtc->enabled = drm_helper_crtc_in_use(crtc);
299 if (!crtc->enabled) {
300 if (crtc_funcs->disable)
301 (*crtc_funcs->disable)(crtc);
302 else
303 (*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
304 crtc->fb = NULL;
305 }
306 }
307 }
308 EXPORT_SYMBOL(drm_helper_disable_unused_functions);
309
310 /**
311 * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
312 * @encoder: encoder to test
313 * @crtc: crtc to test
314 *
315 * Return false if @encoder can't be driven by @crtc, true otherwise.
316 */
drm_encoder_crtc_ok(struct drm_encoder * encoder,struct drm_crtc * crtc)317 static bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
318 struct drm_crtc *crtc)
319 {
320 struct drm_device *dev;
321 struct drm_crtc *tmp;
322 int crtc_mask = 1;
323
324 WARN(!crtc, "checking null crtc?\n");
325
326 dev = crtc->dev;
327
328 list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {
329 if (tmp == crtc)
330 break;
331 crtc_mask <<= 1;
332 }
333
334 if (encoder->possible_crtcs & crtc_mask)
335 return true;
336 return false;
337 }
338
339 /*
340 * Check the CRTC we're going to map each output to vs. its current
341 * CRTC. If they don't match, we have to disable the output and the CRTC
342 * since the driver will have to re-route things.
343 */
344 static void
drm_crtc_prepare_encoders(struct drm_device * dev)345 drm_crtc_prepare_encoders(struct drm_device *dev)
346 {
347 struct drm_encoder_helper_funcs *encoder_funcs;
348 struct drm_encoder *encoder;
349
350 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
351 encoder_funcs = encoder->helper_private;
352 /* Disable unused encoders */
353 if (encoder->crtc == NULL)
354 drm_encoder_disable(encoder);
355 /* Disable encoders whose CRTC is about to change */
356 if (encoder_funcs->get_crtc &&
357 encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
358 drm_encoder_disable(encoder);
359 }
360 }
361
362 /**
363 * drm_crtc_helper_set_mode - internal helper to set a mode
364 * @crtc: CRTC to program
365 * @mode: mode to use
366 * @x: horizontal offset into the surface
367 * @y: vertical offset into the surface
368 * @old_fb: old framebuffer, for cleanup
369 *
370 * LOCKING:
371 * Caller must hold mode config lock.
372 *
373 * Try to set @mode on @crtc. Give @crtc and its associated connectors a chance
374 * to fixup or reject the mode prior to trying to set it. This is an internal
375 * helper that drivers could e.g. use to update properties that require the
376 * entire output pipe to be disabled and re-enabled in a new configuration. For
377 * example for changing whether audio is enabled on a hdmi link or for changing
378 * panel fitter or dither attributes. It is also called by the
379 * drm_crtc_helper_set_config() helper function to drive the mode setting
380 * sequence.
381 *
382 * RETURNS:
383 * True if the mode was set successfully, or false otherwise.
384 */
drm_crtc_helper_set_mode(struct drm_crtc * crtc,struct drm_display_mode * mode,int x,int y,struct drm_framebuffer * old_fb)385 bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
386 struct drm_display_mode *mode,
387 int x, int y,
388 struct drm_framebuffer *old_fb)
389 {
390 struct drm_device *dev = crtc->dev;
391 struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
392 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
393 struct drm_encoder_helper_funcs *encoder_funcs;
394 int saved_x, saved_y;
395 struct drm_encoder *encoder;
396 bool ret = true;
397
398 crtc->enabled = drm_helper_crtc_in_use(crtc);
399 if (!crtc->enabled)
400 return true;
401
402 adjusted_mode = drm_mode_duplicate(dev, mode);
403 if (!adjusted_mode)
404 return false;
405
406 saved_hwmode = crtc->hwmode;
407 saved_mode = crtc->mode;
408 saved_x = crtc->x;
409 saved_y = crtc->y;
410
411 /* Update crtc values up front so the driver can rely on them for mode
412 * setting.
413 */
414 crtc->mode = *mode;
415 crtc->x = x;
416 crtc->y = y;
417
418 /* Pass our mode to the connectors and the CRTC to give them a chance to
419 * adjust it according to limitations or connector properties, and also
420 * a chance to reject the mode entirely.
421 */
422 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
423
424 if (encoder->crtc != crtc)
425 continue;
426 encoder_funcs = encoder->helper_private;
427 if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
428 adjusted_mode))) {
429 DRM_DEBUG_KMS("Encoder fixup failed\n");
430 goto done;
431 }
432 }
433
434 if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
435 DRM_DEBUG_KMS("CRTC fixup failed\n");
436 goto done;
437 }
438 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
439
440 /* Prepare the encoders and CRTCs before setting the mode. */
441 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
442
443 if (encoder->crtc != crtc)
444 continue;
445 encoder_funcs = encoder->helper_private;
446 /* Disable the encoders as the first thing we do. */
447 encoder_funcs->prepare(encoder);
448 }
449
450 drm_crtc_prepare_encoders(dev);
451
452 crtc_funcs->prepare(crtc);
453
454 /* Set up the DPLL and any encoders state that needs to adjust or depend
455 * on the DPLL.
456 */
457 ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
458 if (!ret)
459 goto done;
460
461 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
462
463 if (encoder->crtc != crtc)
464 continue;
465
466 DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
467 encoder->base.id, drm_get_encoder_name(encoder),
468 mode->base.id, mode->name);
469 encoder_funcs = encoder->helper_private;
470 encoder_funcs->mode_set(encoder, mode, adjusted_mode);
471 }
472
473 /* Now enable the clocks, plane, pipe, and connectors that we set up. */
474 crtc_funcs->commit(crtc);
475
476 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
477
478 if (encoder->crtc != crtc)
479 continue;
480
481 encoder_funcs = encoder->helper_private;
482 encoder_funcs->commit(encoder);
483
484 }
485
486 /* Store real post-adjustment hardware mode. */
487 crtc->hwmode = *adjusted_mode;
488
489 /* Calculate and store various constants which
490 * are later needed by vblank and swap-completion
491 * timestamping. They are derived from true hwmode.
492 */
493 drm_calc_timestamping_constants(crtc);
494
495 /* FIXME: add subpixel order */
496 done:
497 drm_mode_destroy(dev, adjusted_mode);
498 if (!ret) {
499 crtc->hwmode = saved_hwmode;
500 crtc->mode = saved_mode;
501 crtc->x = saved_x;
502 crtc->y = saved_y;
503 }
504
505 return ret;
506 }
507 EXPORT_SYMBOL(drm_crtc_helper_set_mode);
508
509
510 static int
drm_crtc_helper_disable(struct drm_crtc * crtc)511 drm_crtc_helper_disable(struct drm_crtc *crtc)
512 {
513 struct drm_device *dev = crtc->dev;
514 struct drm_connector *connector;
515 struct drm_encoder *encoder;
516
517 /* Decouple all encoders and their attached connectors from this crtc */
518 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
519 if (encoder->crtc != crtc)
520 continue;
521
522 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
523 if (connector->encoder != encoder)
524 continue;
525
526 connector->encoder = NULL;
527 }
528 }
529
530 drm_helper_disable_unused_functions(dev);
531 return 0;
532 }
533
534 /**
535 * drm_crtc_helper_set_config - set a new config from userspace
536 * @set: mode set configuration
537 *
538 * LOCKING:
539 * Caller must hold mode config lock.
540 *
541 * Setup a new configuration, provided by the upper layers (either an ioctl call
542 * from userspace or internally e.g. from the fbdev suppport code) in @set, and
543 * enable it. This is the main helper functions for drivers that implement
544 * kernel mode setting with the crtc helper functions and the assorted
545 * ->prepare(), ->modeset() and ->commit() helper callbacks.
546 *
547 * RETURNS:
548 * Returns 0 on success, -ERRNO on failure.
549 */
drm_crtc_helper_set_config(struct drm_mode_set * set)550 int drm_crtc_helper_set_config(struct drm_mode_set *set)
551 {
552 struct drm_device *dev;
553 struct drm_crtc *save_crtcs, *new_crtc, *crtc;
554 struct drm_encoder *save_encoders, *new_encoder, *encoder;
555 struct drm_framebuffer *old_fb = NULL;
556 bool mode_changed = false; /* if true do a full mode set */
557 bool fb_changed = false; /* if true and !mode_changed just do a flip */
558 struct drm_connector *save_connectors, *connector;
559 int count = 0, ro, fail = 0;
560 struct drm_crtc_helper_funcs *crtc_funcs;
561 struct drm_mode_set save_set;
562 int ret;
563 int i;
564
565 DRM_DEBUG_KMS("\n");
566
567 if (!set)
568 return -EINVAL;
569
570 if (!set->crtc)
571 return -EINVAL;
572
573 if (!set->crtc->helper_private)
574 return -EINVAL;
575
576 crtc_funcs = set->crtc->helper_private;
577
578 if (!set->mode)
579 set->fb = NULL;
580
581 if (set->fb) {
582 DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
583 set->crtc->base.id, set->fb->base.id,
584 (int)set->num_connectors, set->x, set->y);
585 } else {
586 DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
587 return drm_crtc_helper_disable(set->crtc);
588 }
589
590 dev = set->crtc->dev;
591
592 /* Allocate space for the backup of all (non-pointer) crtc, encoder and
593 * connector data. */
594 save_crtcs = kzalloc(dev->mode_config.num_crtc *
595 sizeof(struct drm_crtc), GFP_KERNEL);
596 if (!save_crtcs)
597 return -ENOMEM;
598
599 save_encoders = kzalloc(dev->mode_config.num_encoder *
600 sizeof(struct drm_encoder), GFP_KERNEL);
601 if (!save_encoders) {
602 kfree(save_crtcs);
603 return -ENOMEM;
604 }
605
606 save_connectors = kzalloc(dev->mode_config.num_connector *
607 sizeof(struct drm_connector), GFP_KERNEL);
608 if (!save_connectors) {
609 kfree(save_crtcs);
610 kfree(save_encoders);
611 return -ENOMEM;
612 }
613
614 /* Copy data. Note that driver private data is not affected.
615 * Should anything bad happen only the expected state is
616 * restored, not the drivers personal bookkeeping.
617 */
618 count = 0;
619 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
620 save_crtcs[count++] = *crtc;
621 }
622
623 count = 0;
624 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
625 save_encoders[count++] = *encoder;
626 }
627
628 count = 0;
629 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
630 save_connectors[count++] = *connector;
631 }
632
633 save_set.crtc = set->crtc;
634 save_set.mode = &set->crtc->mode;
635 save_set.x = set->crtc->x;
636 save_set.y = set->crtc->y;
637 save_set.fb = set->crtc->fb;
638
639 /* We should be able to check here if the fb has the same properties
640 * and then just flip_or_move it */
641 if (set->crtc->fb != set->fb) {
642 /* If we have no fb then treat it as a full mode set */
643 if (set->crtc->fb == NULL) {
644 DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
645 mode_changed = true;
646 } else if (set->fb == NULL) {
647 mode_changed = true;
648 } else if (set->fb->depth != set->crtc->fb->depth) {
649 mode_changed = true;
650 } else if (set->fb->bits_per_pixel !=
651 set->crtc->fb->bits_per_pixel) {
652 mode_changed = true;
653 } else if (set->fb->pixel_format !=
654 set->crtc->fb->pixel_format) {
655 mode_changed = true;
656 } else
657 fb_changed = true;
658 }
659
660 if (set->x != set->crtc->x || set->y != set->crtc->y)
661 fb_changed = true;
662
663 if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
664 DRM_DEBUG_KMS("modes are different, full mode set\n");
665 drm_mode_debug_printmodeline(&set->crtc->mode);
666 drm_mode_debug_printmodeline(set->mode);
667 mode_changed = true;
668 }
669
670 /* a) traverse passed in connector list and get encoders for them */
671 count = 0;
672 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
673 struct drm_connector_helper_funcs *connector_funcs =
674 connector->helper_private;
675 new_encoder = connector->encoder;
676 for (ro = 0; ro < set->num_connectors; ro++) {
677 if (set->connectors[ro] == connector) {
678 new_encoder = connector_funcs->best_encoder(connector);
679 /* if we can't get an encoder for a connector
680 we are setting now - then fail */
681 if (new_encoder == NULL)
682 /* don't break so fail path works correct */
683 fail = 1;
684 break;
685 }
686 }
687
688 if (new_encoder != connector->encoder) {
689 DRM_DEBUG_KMS("encoder changed, full mode switch\n");
690 mode_changed = true;
691 /* If the encoder is reused for another connector, then
692 * the appropriate crtc will be set later.
693 */
694 if (connector->encoder)
695 connector->encoder->crtc = NULL;
696 connector->encoder = new_encoder;
697 }
698 }
699
700 if (fail) {
701 ret = -EINVAL;
702 goto fail;
703 }
704
705 count = 0;
706 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
707 if (!connector->encoder)
708 continue;
709
710 if (connector->encoder->crtc == set->crtc)
711 new_crtc = NULL;
712 else
713 new_crtc = connector->encoder->crtc;
714
715 for (ro = 0; ro < set->num_connectors; ro++) {
716 if (set->connectors[ro] == connector)
717 new_crtc = set->crtc;
718 }
719
720 /* Make sure the new CRTC will work with the encoder */
721 if (new_crtc &&
722 !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
723 ret = -EINVAL;
724 goto fail;
725 }
726 if (new_crtc != connector->encoder->crtc) {
727 DRM_DEBUG_KMS("crtc changed, full mode switch\n");
728 mode_changed = true;
729 connector->encoder->crtc = new_crtc;
730 }
731 if (new_crtc) {
732 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
733 connector->base.id, drm_get_connector_name(connector),
734 new_crtc->base.id);
735 } else {
736 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
737 connector->base.id, drm_get_connector_name(connector));
738 }
739 }
740
741 /* mode_set_base is not a required function */
742 if (fb_changed && !crtc_funcs->mode_set_base)
743 mode_changed = true;
744
745 if (mode_changed) {
746 set->crtc->enabled = drm_helper_crtc_in_use(set->crtc);
747 if (set->crtc->enabled) {
748 DRM_DEBUG_KMS("attempting to set mode from"
749 " userspace\n");
750 drm_mode_debug_printmodeline(set->mode);
751 old_fb = set->crtc->fb;
752 set->crtc->fb = set->fb;
753 if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
754 set->x, set->y,
755 old_fb)) {
756 DRM_ERROR("failed to set mode on [CRTC:%d]\n",
757 set->crtc->base.id);
758 set->crtc->fb = old_fb;
759 ret = -EINVAL;
760 goto fail;
761 }
762 DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
763 for (i = 0; i < set->num_connectors; i++) {
764 DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
765 drm_get_connector_name(set->connectors[i]));
766 set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
767 }
768 }
769 drm_helper_disable_unused_functions(dev);
770 } else if (fb_changed) {
771 set->crtc->x = set->x;
772 set->crtc->y = set->y;
773
774 old_fb = set->crtc->fb;
775 if (set->crtc->fb != set->fb)
776 set->crtc->fb = set->fb;
777 ret = crtc_funcs->mode_set_base(set->crtc,
778 set->x, set->y, old_fb);
779 if (ret != 0) {
780 set->crtc->fb = old_fb;
781 goto fail;
782 }
783 }
784
785 kfree(save_connectors);
786 kfree(save_encoders);
787 kfree(save_crtcs);
788 return 0;
789
790 fail:
791 /* Restore all previous data. */
792 count = 0;
793 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
794 *crtc = save_crtcs[count++];
795 }
796
797 count = 0;
798 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
799 *encoder = save_encoders[count++];
800 }
801
802 count = 0;
803 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
804 *connector = save_connectors[count++];
805 }
806
807 /* Try to restore the config */
808 if (mode_changed &&
809 !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
810 save_set.y, save_set.fb))
811 DRM_ERROR("failed to restore config after modeset failure\n");
812
813 kfree(save_connectors);
814 kfree(save_encoders);
815 kfree(save_crtcs);
816 return ret;
817 }
818 EXPORT_SYMBOL(drm_crtc_helper_set_config);
819
drm_helper_choose_encoder_dpms(struct drm_encoder * encoder)820 static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
821 {
822 int dpms = DRM_MODE_DPMS_OFF;
823 struct drm_connector *connector;
824 struct drm_device *dev = encoder->dev;
825
826 list_for_each_entry(connector, &dev->mode_config.connector_list, head)
827 if (connector->encoder == encoder)
828 if (connector->dpms < dpms)
829 dpms = connector->dpms;
830 return dpms;
831 }
832
drm_helper_choose_crtc_dpms(struct drm_crtc * crtc)833 static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
834 {
835 int dpms = DRM_MODE_DPMS_OFF;
836 struct drm_connector *connector;
837 struct drm_device *dev = crtc->dev;
838
839 list_for_each_entry(connector, &dev->mode_config.connector_list, head)
840 if (connector->encoder && connector->encoder->crtc == crtc)
841 if (connector->dpms < dpms)
842 dpms = connector->dpms;
843 return dpms;
844 }
845
846 /**
847 * drm_helper_connector_dpms() - connector dpms helper implementation
848 * @connector: affected connector
849 * @mode: DPMS mode
850 *
851 * This is the main helper function provided by the crtc helper framework for
852 * implementing the DPMS connector attribute. It computes the new desired DPMS
853 * state for all encoders and crtcs in the output mesh and calls the ->dpms()
854 * callback provided by the driver appropriately.
855 */
drm_helper_connector_dpms(struct drm_connector * connector,int mode)856 void drm_helper_connector_dpms(struct drm_connector *connector, int mode)
857 {
858 struct drm_encoder *encoder = connector->encoder;
859 struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
860 int old_dpms;
861
862 if (mode == connector->dpms)
863 return;
864
865 old_dpms = connector->dpms;
866 connector->dpms = mode;
867
868 /* from off to on, do crtc then encoder */
869 if (mode < old_dpms) {
870 if (crtc) {
871 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
872 if (crtc_funcs->dpms)
873 (*crtc_funcs->dpms) (crtc,
874 drm_helper_choose_crtc_dpms(crtc));
875 }
876 if (encoder) {
877 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
878 if (encoder_funcs->dpms)
879 (*encoder_funcs->dpms) (encoder,
880 drm_helper_choose_encoder_dpms(encoder));
881 }
882 }
883
884 /* from on to off, do encoder then crtc */
885 if (mode > old_dpms) {
886 if (encoder) {
887 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
888 if (encoder_funcs->dpms)
889 (*encoder_funcs->dpms) (encoder,
890 drm_helper_choose_encoder_dpms(encoder));
891 }
892 if (crtc) {
893 struct drm_crtc_helper_funcs *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 return;
901 }
902 EXPORT_SYMBOL(drm_helper_connector_dpms);
903
drm_helper_mode_fill_fb_struct(struct drm_framebuffer * fb,struct drm_mode_fb_cmd2 * mode_cmd)904 int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
905 struct drm_mode_fb_cmd2 *mode_cmd)
906 {
907 int i;
908
909 fb->width = mode_cmd->width;
910 fb->height = mode_cmd->height;
911 for (i = 0; i < 4; i++) {
912 fb->pitches[i] = mode_cmd->pitches[i];
913 fb->offsets[i] = mode_cmd->offsets[i];
914 }
915 drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
916 &fb->bits_per_pixel);
917 fb->pixel_format = mode_cmd->pixel_format;
918
919 return 0;
920 }
921 EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
922
drm_helper_resume_force_mode(struct drm_device * dev)923 int drm_helper_resume_force_mode(struct drm_device *dev)
924 {
925 struct drm_crtc *crtc;
926 struct drm_encoder *encoder;
927 struct drm_encoder_helper_funcs *encoder_funcs;
928 struct drm_crtc_helper_funcs *crtc_funcs;
929 int ret;
930
931 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
932
933 if (!crtc->enabled)
934 continue;
935
936 ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
937 crtc->x, crtc->y, crtc->fb);
938
939 if (ret == false)
940 DRM_ERROR("failed to set mode on crtc %p\n", crtc);
941
942 /* Turn off outputs that were already powered off */
943 if (drm_helper_choose_crtc_dpms(crtc)) {
944 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
945
946 if(encoder->crtc != crtc)
947 continue;
948
949 encoder_funcs = encoder->helper_private;
950 if (encoder_funcs->dpms)
951 (*encoder_funcs->dpms) (encoder,
952 drm_helper_choose_encoder_dpms(encoder));
953 }
954
955 crtc_funcs = crtc->helper_private;
956 if (crtc_funcs->dpms)
957 (*crtc_funcs->dpms) (crtc,
958 drm_helper_choose_crtc_dpms(crtc));
959 }
960 }
961 /* disable the unused connectors while restoring the modesetting */
962 drm_helper_disable_unused_functions(dev);
963 return 0;
964 }
965 EXPORT_SYMBOL(drm_helper_resume_force_mode);
966
drm_kms_helper_hotplug_event(struct drm_device * dev)967 void drm_kms_helper_hotplug_event(struct drm_device *dev)
968 {
969 /* send a uevent + call fbdev */
970 drm_sysfs_hotplug_event(dev);
971 if (dev->mode_config.funcs->output_poll_changed)
972 dev->mode_config.funcs->output_poll_changed(dev);
973 }
974 EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
975
976 #define DRM_OUTPUT_POLL_PERIOD (10*HZ)
output_poll_execute(struct work_struct * work)977 static void output_poll_execute(struct work_struct *work)
978 {
979 struct delayed_work *delayed_work = to_delayed_work(work);
980 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
981 struct drm_connector *connector;
982 enum drm_connector_status old_status;
983 bool repoll = false, changed = false;
984
985 if (!drm_kms_helper_poll)
986 return;
987
988 mutex_lock(&dev->mode_config.mutex);
989 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
990
991 /* Ignore forced connectors. */
992 if (connector->force)
993 continue;
994
995 /* Ignore HPD capable connectors and connectors where we don't
996 * want any hotplug detection at all for polling. */
997 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
998 continue;
999
1000 repoll = true;
1001
1002 old_status = connector->status;
1003 /* if we are connected and don't want to poll for disconnect
1004 skip it */
1005 if (old_status == connector_status_connected &&
1006 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
1007 continue;
1008
1009 connector->status = connector->funcs->detect(connector, false);
1010 if (old_status != connector->status) {
1011 const char *old, *new;
1012
1013 old = drm_get_connector_status_name(old_status);
1014 new = drm_get_connector_status_name(connector->status);
1015
1016 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] "
1017 "status updated from %s to %s\n",
1018 connector->base.id,
1019 drm_get_connector_name(connector),
1020 old, new);
1021
1022 changed = true;
1023 }
1024 }
1025
1026 mutex_unlock(&dev->mode_config.mutex);
1027
1028 if (changed)
1029 drm_kms_helper_hotplug_event(dev);
1030
1031 if (repoll)
1032 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
1033 }
1034
drm_kms_helper_poll_disable(struct drm_device * dev)1035 void drm_kms_helper_poll_disable(struct drm_device *dev)
1036 {
1037 if (!dev->mode_config.poll_enabled)
1038 return;
1039 cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
1040 }
1041 EXPORT_SYMBOL(drm_kms_helper_poll_disable);
1042
drm_kms_helper_poll_enable(struct drm_device * dev)1043 void drm_kms_helper_poll_enable(struct drm_device *dev)
1044 {
1045 bool poll = false;
1046 struct drm_connector *connector;
1047
1048 if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
1049 return;
1050
1051 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1052 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
1053 DRM_CONNECTOR_POLL_DISCONNECT))
1054 poll = true;
1055 }
1056
1057 if (poll)
1058 schedule_delayed_work(&dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD);
1059 }
1060 EXPORT_SYMBOL(drm_kms_helper_poll_enable);
1061
drm_kms_helper_poll_init(struct drm_device * dev)1062 void drm_kms_helper_poll_init(struct drm_device *dev)
1063 {
1064 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
1065 dev->mode_config.poll_enabled = true;
1066
1067 drm_kms_helper_poll_enable(dev);
1068 }
1069 EXPORT_SYMBOL(drm_kms_helper_poll_init);
1070
drm_kms_helper_poll_fini(struct drm_device * dev)1071 void drm_kms_helper_poll_fini(struct drm_device *dev)
1072 {
1073 drm_kms_helper_poll_disable(dev);
1074 }
1075 EXPORT_SYMBOL(drm_kms_helper_poll_fini);
1076
drm_helper_hpd_irq_event(struct drm_device * dev)1077 void drm_helper_hpd_irq_event(struct drm_device *dev)
1078 {
1079 struct drm_connector *connector;
1080 enum drm_connector_status old_status;
1081 bool changed = false;
1082
1083 if (!dev->mode_config.poll_enabled)
1084 return;
1085
1086 mutex_lock(&dev->mode_config.mutex);
1087 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1088
1089 /* Only handle HPD capable connectors. */
1090 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
1091 continue;
1092
1093 old_status = connector->status;
1094
1095 connector->status = connector->funcs->detect(connector, false);
1096 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
1097 connector->base.id,
1098 drm_get_connector_name(connector),
1099 drm_get_connector_status_name(old_status),
1100 drm_get_connector_status_name(connector->status));
1101 if (old_status != connector->status)
1102 changed = true;
1103 }
1104
1105 mutex_unlock(&dev->mode_config.mutex);
1106
1107 if (changed)
1108 drm_kms_helper_hotplug_event(dev);
1109 }
1110 EXPORT_SYMBOL(drm_helper_hpd_irq_event);
1111