Loading...
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/drm_bridge.h>
36#include <drm/drm_client.h>
37#include <drm/drm_crtc.h>
38#include <drm/drm_edid.h>
39#include <drm/drm_fb_helper.h>
40#include <drm/drm_fourcc.h>
41#include <drm/drm_modeset_helper_vtables.h>
42#include <drm/drm_print.h>
43#include <drm/drm_probe_helper.h>
44#include <drm/drm_sysfs.h>
45
46#include "drm_crtc_helper_internal.h"
47
48/**
49 * DOC: output probing helper overview
50 *
51 * This library provides some helper code for output probing. It provides an
52 * implementation of the core &drm_connector_funcs.fill_modes interface with
53 * drm_helper_probe_single_connector_modes().
54 *
55 * It also provides support for polling connectors with a work item and for
56 * generic hotplug interrupt handling where the driver doesn't or cannot keep
57 * track of a per-connector hpd interrupt.
58 *
59 * This helper library can be used independently of the modeset helper library.
60 * Drivers can also overwrite different parts e.g. use their own hotplug
61 * handling code to avoid probing unrelated outputs.
62 *
63 * The probe helpers share the function table structures with other display
64 * helper libraries. See &struct drm_connector_helper_funcs for the details.
65 */
66
67static bool drm_kms_helper_poll = true;
68module_param_named(poll, drm_kms_helper_poll, bool, 0600);
69
70static enum drm_mode_status
71drm_mode_validate_flag(const struct drm_display_mode *mode,
72 int flags)
73{
74 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
75 !(flags & DRM_MODE_FLAG_INTERLACE))
76 return MODE_NO_INTERLACE;
77
78 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
79 !(flags & DRM_MODE_FLAG_DBLSCAN))
80 return MODE_NO_DBLESCAN;
81
82 if ((mode->flags & DRM_MODE_FLAG_3D_MASK) &&
83 !(flags & DRM_MODE_FLAG_3D_MASK))
84 return MODE_NO_STEREO;
85
86 return MODE_OK;
87}
88
89static int
90drm_mode_validate_pipeline(struct drm_display_mode *mode,
91 struct drm_connector *connector,
92 struct drm_modeset_acquire_ctx *ctx,
93 enum drm_mode_status *status)
94{
95 struct drm_device *dev = connector->dev;
96 struct drm_encoder *encoder;
97 int ret;
98
99 /* Step 1: Validate against connector */
100 ret = drm_connector_mode_valid(connector, mode, ctx, status);
101 if (ret || *status != MODE_OK)
102 return ret;
103
104 /* Step 2: Validate against encoders and crtcs */
105 drm_connector_for_each_possible_encoder(connector, encoder) {
106 struct drm_bridge *bridge;
107 struct drm_crtc *crtc;
108
109 *status = drm_encoder_mode_valid(encoder, mode);
110 if (*status != MODE_OK) {
111 /* No point in continuing for crtc check as this encoder
112 * will not accept the mode anyway. If all encoders
113 * reject the mode then, at exit, ret will not be
114 * MODE_OK. */
115 continue;
116 }
117
118 bridge = drm_bridge_chain_get_first_bridge(encoder);
119 *status = drm_bridge_chain_mode_valid(bridge,
120 &connector->display_info,
121 mode);
122 if (*status != MODE_OK) {
123 /* There is also no point in continuing for crtc check
124 * here. */
125 continue;
126 }
127
128 drm_for_each_crtc(crtc, dev) {
129 if (!drm_encoder_crtc_ok(encoder, crtc))
130 continue;
131
132 *status = drm_crtc_mode_valid(crtc, mode);
133 if (*status == MODE_OK) {
134 /* If we get to this point there is at least
135 * one combination of encoder+crtc that works
136 * for this mode. Lets return now. */
137 return 0;
138 }
139 }
140 }
141
142 return 0;
143}
144
145static int drm_helper_probe_add_cmdline_mode(struct drm_connector *connector)
146{
147 struct drm_cmdline_mode *cmdline_mode;
148 struct drm_display_mode *mode;
149
150 cmdline_mode = &connector->cmdline_mode;
151 if (!cmdline_mode->specified)
152 return 0;
153
154 /* Only add a GTF mode if we find no matching probed modes */
155 list_for_each_entry(mode, &connector->probed_modes, head) {
156 if (mode->hdisplay != cmdline_mode->xres ||
157 mode->vdisplay != cmdline_mode->yres)
158 continue;
159
160 if (cmdline_mode->refresh_specified) {
161 /* The probed mode's vrefresh is set until later */
162 if (drm_mode_vrefresh(mode) != cmdline_mode->refresh)
163 continue;
164 }
165
166 /* Mark the matching mode as being preferred by the user */
167 mode->type |= DRM_MODE_TYPE_USERDEF;
168 return 0;
169 }
170
171 mode = drm_mode_create_from_cmdline_mode(connector->dev,
172 cmdline_mode);
173 if (mode == NULL)
174 return 0;
175
176 drm_mode_probed_add(connector, mode);
177 return 1;
178}
179
180enum drm_mode_status drm_crtc_mode_valid(struct drm_crtc *crtc,
181 const struct drm_display_mode *mode)
182{
183 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
184
185 if (!crtc_funcs || !crtc_funcs->mode_valid)
186 return MODE_OK;
187
188 return crtc_funcs->mode_valid(crtc, mode);
189}
190
191enum drm_mode_status drm_encoder_mode_valid(struct drm_encoder *encoder,
192 const struct drm_display_mode *mode)
193{
194 const struct drm_encoder_helper_funcs *encoder_funcs =
195 encoder->helper_private;
196
197 if (!encoder_funcs || !encoder_funcs->mode_valid)
198 return MODE_OK;
199
200 return encoder_funcs->mode_valid(encoder, mode);
201}
202
203int
204drm_connector_mode_valid(struct drm_connector *connector,
205 struct drm_display_mode *mode,
206 struct drm_modeset_acquire_ctx *ctx,
207 enum drm_mode_status *status)
208{
209 const struct drm_connector_helper_funcs *connector_funcs =
210 connector->helper_private;
211 int ret = 0;
212
213 if (!connector_funcs)
214 *status = MODE_OK;
215 else if (connector_funcs->mode_valid_ctx)
216 ret = connector_funcs->mode_valid_ctx(connector, mode, ctx,
217 status);
218 else if (connector_funcs->mode_valid)
219 *status = connector_funcs->mode_valid(connector, mode);
220 else
221 *status = MODE_OK;
222
223 return ret;
224}
225
226#define DRM_OUTPUT_POLL_PERIOD (10*HZ)
227/**
228 * drm_kms_helper_poll_enable - re-enable output polling.
229 * @dev: drm_device
230 *
231 * This function re-enables the output polling work, after it has been
232 * temporarily disabled using drm_kms_helper_poll_disable(), for example over
233 * suspend/resume.
234 *
235 * Drivers can call this helper from their device resume implementation. It is
236 * not an error to call this even when output polling isn't enabled.
237 *
238 * Note that calls to enable and disable polling must be strictly ordered, which
239 * is automatically the case when they're only call from suspend/resume
240 * callbacks.
241 */
242void drm_kms_helper_poll_enable(struct drm_device *dev)
243{
244 bool poll = false;
245 struct drm_connector *connector;
246 struct drm_connector_list_iter conn_iter;
247 unsigned long delay = DRM_OUTPUT_POLL_PERIOD;
248
249 if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
250 return;
251
252 drm_connector_list_iter_begin(dev, &conn_iter);
253 drm_for_each_connector_iter(connector, &conn_iter) {
254 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
255 DRM_CONNECTOR_POLL_DISCONNECT))
256 poll = true;
257 }
258 drm_connector_list_iter_end(&conn_iter);
259
260 if (dev->mode_config.delayed_event) {
261 /*
262 * FIXME:
263 *
264 * Use short (1s) delay to handle the initial delayed event.
265 * This delay should not be needed, but Optimus/nouveau will
266 * fail in a mysterious way if the delayed event is handled as
267 * soon as possible like it is done in
268 * drm_helper_probe_single_connector_modes() in case the poll
269 * was enabled before.
270 */
271 poll = true;
272 delay = HZ;
273 }
274
275 if (poll)
276 schedule_delayed_work(&dev->mode_config.output_poll_work, delay);
277}
278EXPORT_SYMBOL(drm_kms_helper_poll_enable);
279
280static enum drm_connector_status
281drm_helper_probe_detect_ctx(struct drm_connector *connector, bool force)
282{
283 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
284 struct drm_modeset_acquire_ctx ctx;
285 int ret;
286
287 drm_modeset_acquire_init(&ctx, 0);
288
289retry:
290 ret = drm_modeset_lock(&connector->dev->mode_config.connection_mutex, &ctx);
291 if (!ret) {
292 if (funcs->detect_ctx)
293 ret = funcs->detect_ctx(connector, &ctx, force);
294 else if (connector->funcs->detect)
295 ret = connector->funcs->detect(connector, force);
296 else
297 ret = connector_status_connected;
298 }
299
300 if (ret == -EDEADLK) {
301 drm_modeset_backoff(&ctx);
302 goto retry;
303 }
304
305 if (WARN_ON(ret < 0))
306 ret = connector_status_unknown;
307
308 if (ret != connector->status)
309 connector->epoch_counter += 1;
310
311 drm_modeset_drop_locks(&ctx);
312 drm_modeset_acquire_fini(&ctx);
313
314 return ret;
315}
316
317/**
318 * drm_helper_probe_detect - probe connector status
319 * @connector: connector to probe
320 * @ctx: acquire_ctx, or NULL to let this function handle locking.
321 * @force: Whether destructive probe operations should be performed.
322 *
323 * This function calls the detect callbacks of the connector.
324 * This function returns &drm_connector_status, or
325 * if @ctx is set, it might also return -EDEADLK.
326 */
327int
328drm_helper_probe_detect(struct drm_connector *connector,
329 struct drm_modeset_acquire_ctx *ctx,
330 bool force)
331{
332 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
333 struct drm_device *dev = connector->dev;
334 int ret;
335
336 if (!ctx)
337 return drm_helper_probe_detect_ctx(connector, force);
338
339 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
340 if (ret)
341 return ret;
342
343 if (funcs->detect_ctx)
344 ret = funcs->detect_ctx(connector, ctx, force);
345 else if (connector->funcs->detect)
346 ret = connector->funcs->detect(connector, force);
347 else
348 ret = connector_status_connected;
349
350 if (ret != connector->status)
351 connector->epoch_counter += 1;
352
353 return ret;
354}
355EXPORT_SYMBOL(drm_helper_probe_detect);
356
357/**
358 * drm_helper_probe_single_connector_modes - get complete set of display modes
359 * @connector: connector to probe
360 * @maxX: max width for modes
361 * @maxY: max height for modes
362 *
363 * Based on the helper callbacks implemented by @connector in struct
364 * &drm_connector_helper_funcs try to detect all valid modes. Modes will first
365 * be added to the connector's probed_modes list, then culled (based on validity
366 * and the @maxX, @maxY parameters) and put into the normal modes list.
367 *
368 * Intended to be used as a generic implementation of the
369 * &drm_connector_funcs.fill_modes() vfunc for drivers that use the CRTC helpers
370 * for output mode filtering and detection.
371 *
372 * The basic procedure is as follows
373 *
374 * 1. All modes currently on the connector's modes list are marked as stale
375 *
376 * 2. New modes are added to the connector's probed_modes list with
377 * drm_mode_probed_add(). New modes start their life with status as OK.
378 * Modes are added from a single source using the following priority order.
379 *
380 * - &drm_connector_helper_funcs.get_modes vfunc
381 * - if the connector status is connector_status_connected, standard
382 * VESA DMT modes up to 1024x768 are automatically added
383 * (drm_add_modes_noedid())
384 *
385 * Finally modes specified via the kernel command line (video=...) are
386 * added in addition to what the earlier probes produced
387 * (drm_helper_probe_add_cmdline_mode()). These modes are generated
388 * using the VESA GTF/CVT formulas.
389 *
390 * 3. Modes are moved from the probed_modes list to the modes list. Potential
391 * duplicates are merged together (see drm_connector_list_update()).
392 * After this step the probed_modes list will be empty again.
393 *
394 * 4. Any non-stale mode on the modes list then undergoes validation
395 *
396 * - drm_mode_validate_basic() performs basic sanity checks
397 * - drm_mode_validate_size() filters out modes larger than @maxX and @maxY
398 * (if specified)
399 * - drm_mode_validate_flag() checks the modes against basic connector
400 * capabilities (interlace_allowed,doublescan_allowed,stereo_allowed)
401 * - the optional &drm_connector_helper_funcs.mode_valid or
402 * &drm_connector_helper_funcs.mode_valid_ctx helpers can perform driver
403 * and/or sink specific checks
404 * - the optional &drm_crtc_helper_funcs.mode_valid,
405 * &drm_bridge_funcs.mode_valid and &drm_encoder_helper_funcs.mode_valid
406 * helpers can perform driver and/or source specific checks which are also
407 * enforced by the modeset/atomic helpers
408 *
409 * 5. Any mode whose status is not OK is pruned from the connector's modes list,
410 * accompanied by a debug message indicating the reason for the mode's
411 * rejection (see drm_mode_prune_invalid()).
412 *
413 * Returns:
414 * The number of modes found on @connector.
415 */
416int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
417 uint32_t maxX, uint32_t maxY)
418{
419 struct drm_device *dev = connector->dev;
420 struct drm_display_mode *mode;
421 const struct drm_connector_helper_funcs *connector_funcs =
422 connector->helper_private;
423 int count = 0, ret;
424 int mode_flags = 0;
425 bool verbose_prune = true;
426 enum drm_connector_status old_status;
427 struct drm_modeset_acquire_ctx ctx;
428
429 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
430
431 drm_modeset_acquire_init(&ctx, 0);
432
433 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
434 connector->name);
435
436retry:
437 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx);
438 if (ret == -EDEADLK) {
439 drm_modeset_backoff(&ctx);
440 goto retry;
441 } else
442 WARN_ON(ret < 0);
443
444 /* set all old modes to the stale state */
445 list_for_each_entry(mode, &connector->modes, head)
446 mode->status = MODE_STALE;
447
448 old_status = connector->status;
449
450 if (connector->force) {
451 if (connector->force == DRM_FORCE_ON ||
452 connector->force == DRM_FORCE_ON_DIGITAL)
453 connector->status = connector_status_connected;
454 else
455 connector->status = connector_status_disconnected;
456 if (connector->funcs->force)
457 connector->funcs->force(connector);
458 } else {
459 ret = drm_helper_probe_detect(connector, &ctx, true);
460
461 if (ret == -EDEADLK) {
462 drm_modeset_backoff(&ctx);
463 goto retry;
464 } else if (WARN(ret < 0, "Invalid return value %i for connector detection\n", ret))
465 ret = connector_status_unknown;
466
467 connector->status = ret;
468 }
469
470 /*
471 * Normally either the driver's hpd code or the poll loop should
472 * pick up any changes and fire the hotplug event. But if
473 * userspace sneaks in a probe, we might miss a change. Hence
474 * check here, and if anything changed start the hotplug code.
475 */
476 if (old_status != connector->status) {
477 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
478 connector->base.id,
479 connector->name,
480 drm_get_connector_status_name(old_status),
481 drm_get_connector_status_name(connector->status));
482
483 /*
484 * The hotplug event code might call into the fb
485 * helpers, and so expects that we do not hold any
486 * locks. Fire up the poll struct instead, it will
487 * disable itself again.
488 */
489 dev->mode_config.delayed_event = true;
490 if (dev->mode_config.poll_enabled)
491 schedule_delayed_work(&dev->mode_config.output_poll_work,
492 0);
493 }
494
495 /* Re-enable polling in case the global poll config changed. */
496 if (drm_kms_helper_poll != dev->mode_config.poll_running)
497 drm_kms_helper_poll_enable(dev);
498
499 dev->mode_config.poll_running = drm_kms_helper_poll;
500
501 if (connector->status == connector_status_disconnected) {
502 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
503 connector->base.id, connector->name);
504 drm_connector_update_edid_property(connector, NULL);
505 verbose_prune = false;
506 goto prune;
507 }
508
509 count = (*connector_funcs->get_modes)(connector);
510
511 /*
512 * Fallback for when DDC probe failed in drm_get_edid() and thus skipped
513 * override/firmware EDID.
514 */
515 if (count == 0 && connector->status == connector_status_connected)
516 count = drm_add_override_edid_modes(connector);
517
518 if (count == 0 && connector->status == connector_status_connected)
519 count = drm_add_modes_noedid(connector, 1024, 768);
520 count += drm_helper_probe_add_cmdline_mode(connector);
521 if (count == 0)
522 goto prune;
523
524 drm_connector_list_update(connector);
525
526 if (connector->interlace_allowed)
527 mode_flags |= DRM_MODE_FLAG_INTERLACE;
528 if (connector->doublescan_allowed)
529 mode_flags |= DRM_MODE_FLAG_DBLSCAN;
530 if (connector->stereo_allowed)
531 mode_flags |= DRM_MODE_FLAG_3D_MASK;
532
533 list_for_each_entry(mode, &connector->modes, head) {
534 if (mode->status != MODE_OK)
535 continue;
536
537 mode->status = drm_mode_validate_driver(dev, mode);
538 if (mode->status != MODE_OK)
539 continue;
540
541 mode->status = drm_mode_validate_size(mode, maxX, maxY);
542 if (mode->status != MODE_OK)
543 continue;
544
545 mode->status = drm_mode_validate_flag(mode, mode_flags);
546 if (mode->status != MODE_OK)
547 continue;
548
549 ret = drm_mode_validate_pipeline(mode, connector, &ctx,
550 &mode->status);
551 if (ret) {
552 drm_dbg_kms(dev,
553 "drm_mode_validate_pipeline failed: %d\n",
554 ret);
555
556 if (drm_WARN_ON_ONCE(dev, ret != -EDEADLK)) {
557 mode->status = MODE_ERROR;
558 } else {
559 drm_modeset_backoff(&ctx);
560 goto retry;
561 }
562 }
563
564 if (mode->status != MODE_OK)
565 continue;
566 mode->status = drm_mode_validate_ycbcr420(mode, connector);
567 }
568
569prune:
570 drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);
571
572 drm_modeset_drop_locks(&ctx);
573 drm_modeset_acquire_fini(&ctx);
574
575 if (list_empty(&connector->modes))
576 return 0;
577
578 drm_mode_sort(&connector->modes);
579
580 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
581 connector->name);
582 list_for_each_entry(mode, &connector->modes, head) {
583 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
584 drm_mode_debug_printmodeline(mode);
585 }
586
587 return count;
588}
589EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
590
591/**
592 * drm_kms_helper_hotplug_event - fire off KMS hotplug events
593 * @dev: drm_device whose connector state changed
594 *
595 * This function fires off the uevent for userspace and also calls the
596 * output_poll_changed function, which is most commonly used to inform the fbdev
597 * emulation code and allow it to update the fbcon output configuration.
598 *
599 * Drivers should call this from their hotplug handling code when a change is
600 * detected. Note that this function does not do any output detection of its
601 * own, like drm_helper_hpd_irq_event() does - this is assumed to be done by the
602 * driver already.
603 *
604 * This function must be called from process context with no mode
605 * setting locks held.
606 */
607void drm_kms_helper_hotplug_event(struct drm_device *dev)
608{
609 /* send a uevent + call fbdev */
610 drm_sysfs_hotplug_event(dev);
611 if (dev->mode_config.funcs->output_poll_changed)
612 dev->mode_config.funcs->output_poll_changed(dev);
613
614 drm_client_dev_hotplug(dev);
615}
616EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
617
618static void output_poll_execute(struct work_struct *work)
619{
620 struct delayed_work *delayed_work = to_delayed_work(work);
621 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
622 struct drm_connector *connector;
623 struct drm_connector_list_iter conn_iter;
624 enum drm_connector_status old_status;
625 bool repoll = false, changed;
626
627 if (!dev->mode_config.poll_enabled)
628 return;
629
630 /* Pick up any changes detected by the probe functions. */
631 changed = dev->mode_config.delayed_event;
632 dev->mode_config.delayed_event = false;
633
634 if (!drm_kms_helper_poll)
635 goto out;
636
637 if (!mutex_trylock(&dev->mode_config.mutex)) {
638 repoll = true;
639 goto out;
640 }
641
642 drm_connector_list_iter_begin(dev, &conn_iter);
643 drm_for_each_connector_iter(connector, &conn_iter) {
644 /* Ignore forced connectors. */
645 if (connector->force)
646 continue;
647
648 /* Ignore HPD capable connectors and connectors where we don't
649 * want any hotplug detection at all for polling. */
650 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
651 continue;
652
653 old_status = connector->status;
654 /* if we are connected and don't want to poll for disconnect
655 skip it */
656 if (old_status == connector_status_connected &&
657 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
658 continue;
659
660 repoll = true;
661
662 connector->status = drm_helper_probe_detect(connector, NULL, false);
663 if (old_status != connector->status) {
664 const char *old, *new;
665
666 /*
667 * The poll work sets force=false when calling detect so
668 * that drivers can avoid to do disruptive tests (e.g.
669 * when load detect cycles could cause flickering on
670 * other, running displays). This bears the risk that we
671 * flip-flop between unknown here in the poll work and
672 * the real state when userspace forces a full detect
673 * call after receiving a hotplug event due to this
674 * change.
675 *
676 * Hence clamp an unknown detect status to the old
677 * value.
678 */
679 if (connector->status == connector_status_unknown) {
680 connector->status = old_status;
681 continue;
682 }
683
684 old = drm_get_connector_status_name(old_status);
685 new = drm_get_connector_status_name(connector->status);
686
687 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] "
688 "status updated from %s to %s\n",
689 connector->base.id,
690 connector->name,
691 old, new);
692
693 changed = true;
694 }
695 }
696 drm_connector_list_iter_end(&conn_iter);
697
698 mutex_unlock(&dev->mode_config.mutex);
699
700out:
701 if (changed)
702 drm_kms_helper_hotplug_event(dev);
703
704 if (repoll)
705 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
706}
707
708/**
709 * drm_kms_helper_is_poll_worker - is %current task an output poll worker?
710 *
711 * Determine if %current task is an output poll worker. This can be used
712 * to select distinct code paths for output polling versus other contexts.
713 *
714 * One use case is to avoid a deadlock between the output poll worker and
715 * the autosuspend worker wherein the latter waits for polling to finish
716 * upon calling drm_kms_helper_poll_disable(), while the former waits for
717 * runtime suspend to finish upon calling pm_runtime_get_sync() in a
718 * connector ->detect hook.
719 */
720bool drm_kms_helper_is_poll_worker(void)
721{
722 struct work_struct *work = current_work();
723
724 return work && work->func == output_poll_execute;
725}
726EXPORT_SYMBOL(drm_kms_helper_is_poll_worker);
727
728/**
729 * drm_kms_helper_poll_disable - disable output polling
730 * @dev: drm_device
731 *
732 * This function disables the output polling work.
733 *
734 * Drivers can call this helper from their device suspend implementation. It is
735 * not an error to call this even when output polling isn't enabled or already
736 * disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable().
737 *
738 * Note that calls to enable and disable polling must be strictly ordered, which
739 * is automatically the case when they're only call from suspend/resume
740 * callbacks.
741 */
742void drm_kms_helper_poll_disable(struct drm_device *dev)
743{
744 if (!dev->mode_config.poll_enabled)
745 return;
746 cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
747}
748EXPORT_SYMBOL(drm_kms_helper_poll_disable);
749
750/**
751 * drm_kms_helper_poll_init - initialize and enable output polling
752 * @dev: drm_device
753 *
754 * This function intializes and then also enables output polling support for
755 * @dev. Drivers which do not have reliable hotplug support in hardware can use
756 * this helper infrastructure to regularly poll such connectors for changes in
757 * their connection state.
758 *
759 * Drivers can control which connectors are polled by setting the
760 * DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On
761 * connectors where probing live outputs can result in visual distortion drivers
762 * should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this.
763 * Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are
764 * completely ignored by the polling logic.
765 *
766 * Note that a connector can be both polled and probed from the hotplug handler,
767 * in case the hotplug interrupt is known to be unreliable.
768 */
769void drm_kms_helper_poll_init(struct drm_device *dev)
770{
771 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
772 dev->mode_config.poll_enabled = true;
773
774 drm_kms_helper_poll_enable(dev);
775}
776EXPORT_SYMBOL(drm_kms_helper_poll_init);
777
778/**
779 * drm_kms_helper_poll_fini - disable output polling and clean it up
780 * @dev: drm_device
781 */
782void drm_kms_helper_poll_fini(struct drm_device *dev)
783{
784 if (!dev->mode_config.poll_enabled)
785 return;
786
787 dev->mode_config.poll_enabled = false;
788 cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
789}
790EXPORT_SYMBOL(drm_kms_helper_poll_fini);
791
792/**
793 * drm_helper_hpd_irq_event - hotplug processing
794 * @dev: drm_device
795 *
796 * Drivers can use this helper function to run a detect cycle on all connectors
797 * which have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All
798 * other connectors are ignored, which is useful to avoid reprobing fixed
799 * panels.
800 *
801 * This helper function is useful for drivers which can't or don't track hotplug
802 * interrupts for each connector.
803 *
804 * Drivers which support hotplug interrupts for each connector individually and
805 * which have a more fine-grained detect logic should bypass this code and
806 * directly call drm_kms_helper_hotplug_event() in case the connector state
807 * changed.
808 *
809 * This function must be called from process context with no mode
810 * setting locks held.
811 *
812 * Note that a connector can be both polled and probed from the hotplug handler,
813 * in case the hotplug interrupt is known to be unreliable.
814 */
815bool drm_helper_hpd_irq_event(struct drm_device *dev)
816{
817 struct drm_connector *connector;
818 struct drm_connector_list_iter conn_iter;
819 enum drm_connector_status old_status;
820 bool changed = false;
821 u64 old_epoch_counter;
822
823 if (!dev->mode_config.poll_enabled)
824 return false;
825
826 mutex_lock(&dev->mode_config.mutex);
827 drm_connector_list_iter_begin(dev, &conn_iter);
828 drm_for_each_connector_iter(connector, &conn_iter) {
829 /* Only handle HPD capable connectors. */
830 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
831 continue;
832
833 old_status = connector->status;
834
835 old_epoch_counter = connector->epoch_counter;
836
837 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] Old epoch counter %llu\n", connector->base.id,
838 connector->name,
839 old_epoch_counter);
840
841 connector->status = drm_helper_probe_detect(connector, NULL, false);
842 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
843 connector->base.id,
844 connector->name,
845 drm_get_connector_status_name(old_status),
846 drm_get_connector_status_name(connector->status));
847
848 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] New epoch counter %llu\n",
849 connector->base.id,
850 connector->name,
851 connector->epoch_counter);
852
853 /*
854 * Check if epoch counter had changed, meaning that we need
855 * to send a uevent.
856 */
857 if (old_epoch_counter != connector->epoch_counter)
858 changed = true;
859
860 }
861 drm_connector_list_iter_end(&conn_iter);
862 mutex_unlock(&dev->mode_config.mutex);
863
864 if (changed) {
865 drm_kms_helper_hotplug_event(dev);
866 DRM_DEBUG_KMS("Sent hotplug event\n");
867 }
868
869 return changed;
870}
871EXPORT_SYMBOL(drm_helper_hpd_irq_event);
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/drm_bridge.h>
36#include <drm/drm_client.h>
37#include <drm/drm_crtc.h>
38#include <drm/drm_edid.h>
39#include <drm/drm_fourcc.h>
40#include <drm/drm_modeset_helper_vtables.h>
41#include <drm/drm_print.h>
42#include <drm/drm_probe_helper.h>
43#include <drm/drm_sysfs.h>
44
45#include "drm_crtc_helper_internal.h"
46
47/**
48 * DOC: output probing helper overview
49 *
50 * This library provides some helper code for output probing. It provides an
51 * implementation of the core &drm_connector_funcs.fill_modes interface with
52 * drm_helper_probe_single_connector_modes().
53 *
54 * It also provides support for polling connectors with a work item and for
55 * generic hotplug interrupt handling where the driver doesn't or cannot keep
56 * track of a per-connector hpd interrupt.
57 *
58 * This helper library can be used independently of the modeset helper library.
59 * Drivers can also overwrite different parts e.g. use their own hotplug
60 * handling code to avoid probing unrelated outputs.
61 *
62 * The probe helpers share the function table structures with other display
63 * helper libraries. See &struct drm_connector_helper_funcs for the details.
64 */
65
66static bool drm_kms_helper_poll = true;
67module_param_named(poll, drm_kms_helper_poll, bool, 0600);
68
69static enum drm_mode_status
70drm_mode_validate_flag(const struct drm_display_mode *mode,
71 int flags)
72{
73 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
74 !(flags & DRM_MODE_FLAG_INTERLACE))
75 return MODE_NO_INTERLACE;
76
77 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
78 !(flags & DRM_MODE_FLAG_DBLSCAN))
79 return MODE_NO_DBLESCAN;
80
81 if ((mode->flags & DRM_MODE_FLAG_3D_MASK) &&
82 !(flags & DRM_MODE_FLAG_3D_MASK))
83 return MODE_NO_STEREO;
84
85 return MODE_OK;
86}
87
88static int
89drm_mode_validate_pipeline(struct drm_display_mode *mode,
90 struct drm_connector *connector,
91 struct drm_modeset_acquire_ctx *ctx,
92 enum drm_mode_status *status)
93{
94 struct drm_device *dev = connector->dev;
95 struct drm_encoder *encoder;
96 int ret;
97
98 /* Step 1: Validate against connector */
99 ret = drm_connector_mode_valid(connector, mode, ctx, status);
100 if (ret || *status != MODE_OK)
101 return ret;
102
103 /* Step 2: Validate against encoders and crtcs */
104 drm_connector_for_each_possible_encoder(connector, encoder) {
105 struct drm_bridge *bridge;
106 struct drm_crtc *crtc;
107
108 *status = drm_encoder_mode_valid(encoder, mode);
109 if (*status != MODE_OK) {
110 /* No point in continuing for crtc check as this encoder
111 * will not accept the mode anyway. If all encoders
112 * reject the mode then, at exit, ret will not be
113 * MODE_OK. */
114 continue;
115 }
116
117 bridge = drm_bridge_chain_get_first_bridge(encoder);
118 *status = drm_bridge_chain_mode_valid(bridge,
119 &connector->display_info,
120 mode);
121 if (*status != MODE_OK) {
122 /* There is also no point in continuing for crtc check
123 * here. */
124 continue;
125 }
126
127 drm_for_each_crtc(crtc, dev) {
128 if (!drm_encoder_crtc_ok(encoder, crtc))
129 continue;
130
131 *status = drm_crtc_mode_valid(crtc, mode);
132 if (*status == MODE_OK) {
133 /* If we get to this point there is at least
134 * one combination of encoder+crtc that works
135 * for this mode. Lets return now. */
136 return 0;
137 }
138 }
139 }
140
141 return 0;
142}
143
144static int drm_helper_probe_add_cmdline_mode(struct drm_connector *connector)
145{
146 struct drm_cmdline_mode *cmdline_mode;
147 struct drm_display_mode *mode;
148
149 cmdline_mode = &connector->cmdline_mode;
150 if (!cmdline_mode->specified)
151 return 0;
152
153 /* Only add a GTF mode if we find no matching probed modes */
154 list_for_each_entry(mode, &connector->probed_modes, head) {
155 if (mode->hdisplay != cmdline_mode->xres ||
156 mode->vdisplay != cmdline_mode->yres)
157 continue;
158
159 if (cmdline_mode->refresh_specified) {
160 /* The probed mode's vrefresh is set until later */
161 if (drm_mode_vrefresh(mode) != cmdline_mode->refresh)
162 continue;
163 }
164
165 /* Mark the matching mode as being preferred by the user */
166 mode->type |= DRM_MODE_TYPE_USERDEF;
167 return 0;
168 }
169
170 mode = drm_mode_create_from_cmdline_mode(connector->dev,
171 cmdline_mode);
172 if (mode == NULL)
173 return 0;
174
175 drm_mode_probed_add(connector, mode);
176 return 1;
177}
178
179enum drm_mode_status drm_crtc_mode_valid(struct drm_crtc *crtc,
180 const struct drm_display_mode *mode)
181{
182 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
183
184 if (!crtc_funcs || !crtc_funcs->mode_valid)
185 return MODE_OK;
186
187 return crtc_funcs->mode_valid(crtc, mode);
188}
189
190enum drm_mode_status drm_encoder_mode_valid(struct drm_encoder *encoder,
191 const struct drm_display_mode *mode)
192{
193 const struct drm_encoder_helper_funcs *encoder_funcs =
194 encoder->helper_private;
195
196 if (!encoder_funcs || !encoder_funcs->mode_valid)
197 return MODE_OK;
198
199 return encoder_funcs->mode_valid(encoder, mode);
200}
201
202int
203drm_connector_mode_valid(struct drm_connector *connector,
204 struct drm_display_mode *mode,
205 struct drm_modeset_acquire_ctx *ctx,
206 enum drm_mode_status *status)
207{
208 const struct drm_connector_helper_funcs *connector_funcs =
209 connector->helper_private;
210 int ret = 0;
211
212 if (!connector_funcs)
213 *status = MODE_OK;
214 else if (connector_funcs->mode_valid_ctx)
215 ret = connector_funcs->mode_valid_ctx(connector, mode, ctx,
216 status);
217 else if (connector_funcs->mode_valid)
218 *status = connector_funcs->mode_valid(connector, mode);
219 else
220 *status = MODE_OK;
221
222 return ret;
223}
224
225#define DRM_OUTPUT_POLL_PERIOD (10*HZ)
226/**
227 * drm_kms_helper_poll_enable - re-enable output polling.
228 * @dev: drm_device
229 *
230 * This function re-enables the output polling work, after it has been
231 * temporarily disabled using drm_kms_helper_poll_disable(), for example over
232 * suspend/resume.
233 *
234 * Drivers can call this helper from their device resume implementation. It is
235 * not an error to call this even when output polling isn't enabled.
236 *
237 * Note that calls to enable and disable polling must be strictly ordered, which
238 * is automatically the case when they're only call from suspend/resume
239 * callbacks.
240 */
241void drm_kms_helper_poll_enable(struct drm_device *dev)
242{
243 bool poll = false;
244 struct drm_connector *connector;
245 struct drm_connector_list_iter conn_iter;
246 unsigned long delay = DRM_OUTPUT_POLL_PERIOD;
247
248 if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
249 return;
250
251 drm_connector_list_iter_begin(dev, &conn_iter);
252 drm_for_each_connector_iter(connector, &conn_iter) {
253 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
254 DRM_CONNECTOR_POLL_DISCONNECT))
255 poll = true;
256 }
257 drm_connector_list_iter_end(&conn_iter);
258
259 if (dev->mode_config.delayed_event) {
260 /*
261 * FIXME:
262 *
263 * Use short (1s) delay to handle the initial delayed event.
264 * This delay should not be needed, but Optimus/nouveau will
265 * fail in a mysterious way if the delayed event is handled as
266 * soon as possible like it is done in
267 * drm_helper_probe_single_connector_modes() in case the poll
268 * was enabled before.
269 */
270 poll = true;
271 delay = HZ;
272 }
273
274 if (poll)
275 schedule_delayed_work(&dev->mode_config.output_poll_work, delay);
276}
277EXPORT_SYMBOL(drm_kms_helper_poll_enable);
278
279static enum drm_connector_status
280drm_helper_probe_detect_ctx(struct drm_connector *connector, bool force)
281{
282 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
283 struct drm_modeset_acquire_ctx ctx;
284 int ret;
285
286 drm_modeset_acquire_init(&ctx, 0);
287
288retry:
289 ret = drm_modeset_lock(&connector->dev->mode_config.connection_mutex, &ctx);
290 if (!ret) {
291 if (funcs->detect_ctx)
292 ret = funcs->detect_ctx(connector, &ctx, force);
293 else if (connector->funcs->detect)
294 ret = connector->funcs->detect(connector, force);
295 else
296 ret = connector_status_connected;
297 }
298
299 if (ret == -EDEADLK) {
300 drm_modeset_backoff(&ctx);
301 goto retry;
302 }
303
304 if (WARN_ON(ret < 0))
305 ret = connector_status_unknown;
306
307 if (ret != connector->status)
308 connector->epoch_counter += 1;
309
310 drm_modeset_drop_locks(&ctx);
311 drm_modeset_acquire_fini(&ctx);
312
313 return ret;
314}
315
316/**
317 * drm_helper_probe_detect - probe connector status
318 * @connector: connector to probe
319 * @ctx: acquire_ctx, or NULL to let this function handle locking.
320 * @force: Whether destructive probe operations should be performed.
321 *
322 * This function calls the detect callbacks of the connector.
323 * This function returns &drm_connector_status, or
324 * if @ctx is set, it might also return -EDEADLK.
325 */
326int
327drm_helper_probe_detect(struct drm_connector *connector,
328 struct drm_modeset_acquire_ctx *ctx,
329 bool force)
330{
331 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
332 struct drm_device *dev = connector->dev;
333 int ret;
334
335 if (!ctx)
336 return drm_helper_probe_detect_ctx(connector, force);
337
338 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
339 if (ret)
340 return ret;
341
342 if (funcs->detect_ctx)
343 ret = funcs->detect_ctx(connector, ctx, force);
344 else if (connector->funcs->detect)
345 ret = connector->funcs->detect(connector, force);
346 else
347 ret = connector_status_connected;
348
349 if (ret != connector->status)
350 connector->epoch_counter += 1;
351
352 return ret;
353}
354EXPORT_SYMBOL(drm_helper_probe_detect);
355
356static int drm_helper_probe_get_modes(struct drm_connector *connector)
357{
358 const struct drm_connector_helper_funcs *connector_funcs =
359 connector->helper_private;
360 int count;
361
362 count = connector_funcs->get_modes(connector);
363
364 /*
365 * Fallback for when DDC probe failed in drm_get_edid() and thus skipped
366 * override/firmware EDID.
367 */
368 if (count == 0 && connector->status == connector_status_connected)
369 count = drm_edid_override_connector_update(connector);
370
371 return count;
372}
373
374static int __drm_helper_update_and_validate(struct drm_connector *connector,
375 uint32_t maxX, uint32_t maxY,
376 struct drm_modeset_acquire_ctx *ctx)
377{
378 struct drm_device *dev = connector->dev;
379 struct drm_display_mode *mode;
380 int mode_flags = 0;
381 int ret;
382
383 drm_connector_list_update(connector);
384
385 if (connector->interlace_allowed)
386 mode_flags |= DRM_MODE_FLAG_INTERLACE;
387 if (connector->doublescan_allowed)
388 mode_flags |= DRM_MODE_FLAG_DBLSCAN;
389 if (connector->stereo_allowed)
390 mode_flags |= DRM_MODE_FLAG_3D_MASK;
391
392 list_for_each_entry(mode, &connector->modes, head) {
393 if (mode->status != MODE_OK)
394 continue;
395
396 mode->status = drm_mode_validate_driver(dev, mode);
397 if (mode->status != MODE_OK)
398 continue;
399
400 mode->status = drm_mode_validate_size(mode, maxX, maxY);
401 if (mode->status != MODE_OK)
402 continue;
403
404 mode->status = drm_mode_validate_flag(mode, mode_flags);
405 if (mode->status != MODE_OK)
406 continue;
407
408 ret = drm_mode_validate_pipeline(mode, connector, ctx,
409 &mode->status);
410 if (ret) {
411 drm_dbg_kms(dev,
412 "drm_mode_validate_pipeline failed: %d\n",
413 ret);
414
415 if (drm_WARN_ON_ONCE(dev, ret != -EDEADLK))
416 mode->status = MODE_ERROR;
417 else
418 return -EDEADLK;
419 }
420
421 if (mode->status != MODE_OK)
422 continue;
423 mode->status = drm_mode_validate_ycbcr420(mode, connector);
424 }
425
426 return 0;
427}
428
429/**
430 * drm_helper_probe_single_connector_modes - get complete set of display modes
431 * @connector: connector to probe
432 * @maxX: max width for modes
433 * @maxY: max height for modes
434 *
435 * Based on the helper callbacks implemented by @connector in struct
436 * &drm_connector_helper_funcs try to detect all valid modes. Modes will first
437 * be added to the connector's probed_modes list, then culled (based on validity
438 * and the @maxX, @maxY parameters) and put into the normal modes list.
439 *
440 * Intended to be used as a generic implementation of the
441 * &drm_connector_funcs.fill_modes() vfunc for drivers that use the CRTC helpers
442 * for output mode filtering and detection.
443 *
444 * The basic procedure is as follows
445 *
446 * 1. All modes currently on the connector's modes list are marked as stale
447 *
448 * 2. New modes are added to the connector's probed_modes list with
449 * drm_mode_probed_add(). New modes start their life with status as OK.
450 * Modes are added from a single source using the following priority order.
451 *
452 * - &drm_connector_helper_funcs.get_modes vfunc
453 * - if the connector status is connector_status_connected, standard
454 * VESA DMT modes up to 1024x768 are automatically added
455 * (drm_add_modes_noedid())
456 *
457 * Finally modes specified via the kernel command line (video=...) are
458 * added in addition to what the earlier probes produced
459 * (drm_helper_probe_add_cmdline_mode()). These modes are generated
460 * using the VESA GTF/CVT formulas.
461 *
462 * 3. Modes are moved from the probed_modes list to the modes list. Potential
463 * duplicates are merged together (see drm_connector_list_update()).
464 * After this step the probed_modes list will be empty again.
465 *
466 * 4. Any non-stale mode on the modes list then undergoes validation
467 *
468 * - drm_mode_validate_basic() performs basic sanity checks
469 * - drm_mode_validate_size() filters out modes larger than @maxX and @maxY
470 * (if specified)
471 * - drm_mode_validate_flag() checks the modes against basic connector
472 * capabilities (interlace_allowed,doublescan_allowed,stereo_allowed)
473 * - the optional &drm_connector_helper_funcs.mode_valid or
474 * &drm_connector_helper_funcs.mode_valid_ctx helpers can perform driver
475 * and/or sink specific checks
476 * - the optional &drm_crtc_helper_funcs.mode_valid,
477 * &drm_bridge_funcs.mode_valid and &drm_encoder_helper_funcs.mode_valid
478 * helpers can perform driver and/or source specific checks which are also
479 * enforced by the modeset/atomic helpers
480 *
481 * 5. Any mode whose status is not OK is pruned from the connector's modes list,
482 * accompanied by a debug message indicating the reason for the mode's
483 * rejection (see drm_mode_prune_invalid()).
484 *
485 * Returns:
486 * The number of modes found on @connector.
487 */
488int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
489 uint32_t maxX, uint32_t maxY)
490{
491 struct drm_device *dev = connector->dev;
492 struct drm_display_mode *mode;
493 int count = 0, ret;
494 enum drm_connector_status old_status;
495 struct drm_modeset_acquire_ctx ctx;
496
497 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
498
499 drm_modeset_acquire_init(&ctx, 0);
500
501 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
502 connector->name);
503
504retry:
505 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx);
506 if (ret == -EDEADLK) {
507 drm_modeset_backoff(&ctx);
508 goto retry;
509 } else
510 WARN_ON(ret < 0);
511
512 /* set all old modes to the stale state */
513 list_for_each_entry(mode, &connector->modes, head)
514 mode->status = MODE_STALE;
515
516 old_status = connector->status;
517
518 if (connector->force) {
519 if (connector->force == DRM_FORCE_ON ||
520 connector->force == DRM_FORCE_ON_DIGITAL)
521 connector->status = connector_status_connected;
522 else
523 connector->status = connector_status_disconnected;
524 if (connector->funcs->force)
525 connector->funcs->force(connector);
526 } else {
527 ret = drm_helper_probe_detect(connector, &ctx, true);
528
529 if (ret == -EDEADLK) {
530 drm_modeset_backoff(&ctx);
531 goto retry;
532 } else if (WARN(ret < 0, "Invalid return value %i for connector detection\n", ret))
533 ret = connector_status_unknown;
534
535 connector->status = ret;
536 }
537
538 /*
539 * Normally either the driver's hpd code or the poll loop should
540 * pick up any changes and fire the hotplug event. But if
541 * userspace sneaks in a probe, we might miss a change. Hence
542 * check here, and if anything changed start the hotplug code.
543 */
544 if (old_status != connector->status) {
545 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
546 connector->base.id,
547 connector->name,
548 drm_get_connector_status_name(old_status),
549 drm_get_connector_status_name(connector->status));
550
551 /*
552 * The hotplug event code might call into the fb
553 * helpers, and so expects that we do not hold any
554 * locks. Fire up the poll struct instead, it will
555 * disable itself again.
556 */
557 dev->mode_config.delayed_event = true;
558 if (dev->mode_config.poll_enabled)
559 schedule_delayed_work(&dev->mode_config.output_poll_work,
560 0);
561 }
562
563 /* Re-enable polling in case the global poll config changed. */
564 if (drm_kms_helper_poll != dev->mode_config.poll_running)
565 drm_kms_helper_poll_enable(dev);
566
567 dev->mode_config.poll_running = drm_kms_helper_poll;
568
569 if (connector->status == connector_status_disconnected) {
570 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
571 connector->base.id, connector->name);
572 drm_connector_update_edid_property(connector, NULL);
573 drm_mode_prune_invalid(dev, &connector->modes, false);
574 goto exit;
575 }
576
577 count = drm_helper_probe_get_modes(connector);
578
579 if (count == 0 && (connector->status == connector_status_connected ||
580 connector->status == connector_status_unknown)) {
581 count = drm_add_modes_noedid(connector, 1024, 768);
582
583 /*
584 * Section 4.2.2.6 (EDID Corruption Detection) of the DP 1.4a
585 * Link CTS specifies that 640x480 (the official "failsafe"
586 * mode) needs to be the default if there's no EDID.
587 */
588 if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort)
589 drm_set_preferred_mode(connector, 640, 480);
590 }
591 count += drm_helper_probe_add_cmdline_mode(connector);
592 if (count != 0) {
593 ret = __drm_helper_update_and_validate(connector, maxX, maxY, &ctx);
594 if (ret == -EDEADLK) {
595 drm_modeset_backoff(&ctx);
596 goto retry;
597 }
598 }
599
600 drm_mode_prune_invalid(dev, &connector->modes, true);
601
602 /*
603 * Displayport spec section 5.2.1.2 ("Video Timing Format") says that
604 * all detachable sinks shall support 640x480 @60Hz as a fail safe
605 * mode. If all modes were pruned, perhaps because they need more
606 * lanes or a higher pixel clock than available, at least try to add
607 * in 640x480.
608 */
609 if (list_empty(&connector->modes) &&
610 connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
611 count = drm_add_modes_noedid(connector, 640, 480);
612 ret = __drm_helper_update_and_validate(connector, maxX, maxY, &ctx);
613 if (ret == -EDEADLK) {
614 drm_modeset_backoff(&ctx);
615 goto retry;
616 }
617 drm_mode_prune_invalid(dev, &connector->modes, true);
618 }
619
620exit:
621 drm_modeset_drop_locks(&ctx);
622 drm_modeset_acquire_fini(&ctx);
623
624 if (list_empty(&connector->modes))
625 return 0;
626
627 drm_mode_sort(&connector->modes);
628
629 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
630 connector->name);
631 list_for_each_entry(mode, &connector->modes, head) {
632 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
633 drm_mode_debug_printmodeline(mode);
634 }
635
636 return count;
637}
638EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
639
640/**
641 * drm_kms_helper_hotplug_event - fire off KMS hotplug events
642 * @dev: drm_device whose connector state changed
643 *
644 * This function fires off the uevent for userspace and also calls the
645 * output_poll_changed function, which is most commonly used to inform the fbdev
646 * emulation code and allow it to update the fbcon output configuration.
647 *
648 * Drivers should call this from their hotplug handling code when a change is
649 * detected. Note that this function does not do any output detection of its
650 * own, like drm_helper_hpd_irq_event() does - this is assumed to be done by the
651 * driver already.
652 *
653 * This function must be called from process context with no mode
654 * setting locks held.
655 *
656 * If only a single connector has changed, consider calling
657 * drm_kms_helper_connector_hotplug_event() instead.
658 */
659void drm_kms_helper_hotplug_event(struct drm_device *dev)
660{
661 /* send a uevent + call fbdev */
662 drm_sysfs_hotplug_event(dev);
663 if (dev->mode_config.funcs->output_poll_changed)
664 dev->mode_config.funcs->output_poll_changed(dev);
665
666 drm_client_dev_hotplug(dev);
667}
668EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
669
670/**
671 * drm_kms_helper_connector_hotplug_event - fire off a KMS connector hotplug event
672 * @connector: drm_connector which has changed
673 *
674 * This is the same as drm_kms_helper_hotplug_event(), except it fires a more
675 * fine-grained uevent for a single connector.
676 */
677void drm_kms_helper_connector_hotplug_event(struct drm_connector *connector)
678{
679 struct drm_device *dev = connector->dev;
680
681 /* send a uevent + call fbdev */
682 drm_sysfs_connector_hotplug_event(connector);
683 if (dev->mode_config.funcs->output_poll_changed)
684 dev->mode_config.funcs->output_poll_changed(dev);
685
686 drm_client_dev_hotplug(dev);
687}
688EXPORT_SYMBOL(drm_kms_helper_connector_hotplug_event);
689
690static void output_poll_execute(struct work_struct *work)
691{
692 struct delayed_work *delayed_work = to_delayed_work(work);
693 struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
694 struct drm_connector *connector;
695 struct drm_connector_list_iter conn_iter;
696 enum drm_connector_status old_status;
697 bool repoll = false, changed;
698 u64 old_epoch_counter;
699
700 if (!dev->mode_config.poll_enabled)
701 return;
702
703 /* Pick up any changes detected by the probe functions. */
704 changed = dev->mode_config.delayed_event;
705 dev->mode_config.delayed_event = false;
706
707 if (!drm_kms_helper_poll)
708 goto out;
709
710 if (!mutex_trylock(&dev->mode_config.mutex)) {
711 repoll = true;
712 goto out;
713 }
714
715 drm_connector_list_iter_begin(dev, &conn_iter);
716 drm_for_each_connector_iter(connector, &conn_iter) {
717 /* Ignore forced connectors. */
718 if (connector->force)
719 continue;
720
721 /* Ignore HPD capable connectors and connectors where we don't
722 * want any hotplug detection at all for polling. */
723 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
724 continue;
725
726 old_status = connector->status;
727 /* if we are connected and don't want to poll for disconnect
728 skip it */
729 if (old_status == connector_status_connected &&
730 !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
731 continue;
732
733 repoll = true;
734
735 old_epoch_counter = connector->epoch_counter;
736 connector->status = drm_helper_probe_detect(connector, NULL, false);
737 if (old_epoch_counter != connector->epoch_counter) {
738 const char *old, *new;
739
740 /*
741 * The poll work sets force=false when calling detect so
742 * that drivers can avoid to do disruptive tests (e.g.
743 * when load detect cycles could cause flickering on
744 * other, running displays). This bears the risk that we
745 * flip-flop between unknown here in the poll work and
746 * the real state when userspace forces a full detect
747 * call after receiving a hotplug event due to this
748 * change.
749 *
750 * Hence clamp an unknown detect status to the old
751 * value.
752 */
753 if (connector->status == connector_status_unknown) {
754 connector->status = old_status;
755 continue;
756 }
757
758 old = drm_get_connector_status_name(old_status);
759 new = drm_get_connector_status_name(connector->status);
760
761 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] "
762 "status updated from %s to %s\n",
763 connector->base.id,
764 connector->name,
765 old, new);
766 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] epoch counter %llu -> %llu\n",
767 connector->base.id, connector->name,
768 old_epoch_counter, connector->epoch_counter);
769
770 changed = true;
771 }
772 }
773 drm_connector_list_iter_end(&conn_iter);
774
775 mutex_unlock(&dev->mode_config.mutex);
776
777out:
778 if (changed)
779 drm_kms_helper_hotplug_event(dev);
780
781 if (repoll)
782 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
783}
784
785/**
786 * drm_kms_helper_is_poll_worker - is %current task an output poll worker?
787 *
788 * Determine if %current task is an output poll worker. This can be used
789 * to select distinct code paths for output polling versus other contexts.
790 *
791 * One use case is to avoid a deadlock between the output poll worker and
792 * the autosuspend worker wherein the latter waits for polling to finish
793 * upon calling drm_kms_helper_poll_disable(), while the former waits for
794 * runtime suspend to finish upon calling pm_runtime_get_sync() in a
795 * connector ->detect hook.
796 */
797bool drm_kms_helper_is_poll_worker(void)
798{
799 struct work_struct *work = current_work();
800
801 return work && work->func == output_poll_execute;
802}
803EXPORT_SYMBOL(drm_kms_helper_is_poll_worker);
804
805/**
806 * drm_kms_helper_poll_disable - disable output polling
807 * @dev: drm_device
808 *
809 * This function disables the output polling work.
810 *
811 * Drivers can call this helper from their device suspend implementation. It is
812 * not an error to call this even when output polling isn't enabled or already
813 * disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable().
814 *
815 * Note that calls to enable and disable polling must be strictly ordered, which
816 * is automatically the case when they're only call from suspend/resume
817 * callbacks.
818 */
819void drm_kms_helper_poll_disable(struct drm_device *dev)
820{
821 if (!dev->mode_config.poll_enabled)
822 return;
823 cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
824}
825EXPORT_SYMBOL(drm_kms_helper_poll_disable);
826
827/**
828 * drm_kms_helper_poll_init - initialize and enable output polling
829 * @dev: drm_device
830 *
831 * This function initializes and then also enables output polling support for
832 * @dev. Drivers which do not have reliable hotplug support in hardware can use
833 * this helper infrastructure to regularly poll such connectors for changes in
834 * their connection state.
835 *
836 * Drivers can control which connectors are polled by setting the
837 * DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On
838 * connectors where probing live outputs can result in visual distortion drivers
839 * should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this.
840 * Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are
841 * completely ignored by the polling logic.
842 *
843 * Note that a connector can be both polled and probed from the hotplug handler,
844 * in case the hotplug interrupt is known to be unreliable.
845 */
846void drm_kms_helper_poll_init(struct drm_device *dev)
847{
848 INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
849 dev->mode_config.poll_enabled = true;
850
851 drm_kms_helper_poll_enable(dev);
852}
853EXPORT_SYMBOL(drm_kms_helper_poll_init);
854
855/**
856 * drm_kms_helper_poll_fini - disable output polling and clean it up
857 * @dev: drm_device
858 */
859void drm_kms_helper_poll_fini(struct drm_device *dev)
860{
861 if (!dev->mode_config.poll_enabled)
862 return;
863
864 dev->mode_config.poll_enabled = false;
865 cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
866}
867EXPORT_SYMBOL(drm_kms_helper_poll_fini);
868
869static bool check_connector_changed(struct drm_connector *connector)
870{
871 struct drm_device *dev = connector->dev;
872 enum drm_connector_status old_status;
873 u64 old_epoch_counter;
874
875 /* Only handle HPD capable connectors. */
876 drm_WARN_ON(dev, !(connector->polled & DRM_CONNECTOR_POLL_HPD));
877
878 drm_WARN_ON(dev, !mutex_is_locked(&dev->mode_config.mutex));
879
880 old_status = connector->status;
881 old_epoch_counter = connector->epoch_counter;
882 connector->status = drm_helper_probe_detect(connector, NULL, false);
883
884 if (old_epoch_counter == connector->epoch_counter) {
885 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Same epoch counter %llu\n",
886 connector->base.id,
887 connector->name,
888 connector->epoch_counter);
889
890 return false;
891 }
892
893 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] status updated from %s to %s\n",
894 connector->base.id,
895 connector->name,
896 drm_get_connector_status_name(old_status),
897 drm_get_connector_status_name(connector->status));
898
899 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Changed epoch counter %llu => %llu\n",
900 connector->base.id,
901 connector->name,
902 old_epoch_counter,
903 connector->epoch_counter);
904
905 return true;
906}
907
908/**
909 * drm_connector_helper_hpd_irq_event - hotplug processing
910 * @connector: drm_connector
911 *
912 * Drivers can use this helper function to run a detect cycle on a connector
913 * which has the DRM_CONNECTOR_POLL_HPD flag set in its &polled member.
914 *
915 * This helper function is useful for drivers which can track hotplug
916 * interrupts for a single connector. Drivers that want to send a
917 * hotplug event for all connectors or can't track hotplug interrupts
918 * per connector need to use drm_helper_hpd_irq_event().
919 *
920 * This function must be called from process context with no mode
921 * setting locks held.
922 *
923 * Note that a connector can be both polled and probed from the hotplug
924 * handler, in case the hotplug interrupt is known to be unreliable.
925 *
926 * Returns:
927 * A boolean indicating whether the connector status changed or not
928 */
929bool drm_connector_helper_hpd_irq_event(struct drm_connector *connector)
930{
931 struct drm_device *dev = connector->dev;
932 bool changed;
933
934 mutex_lock(&dev->mode_config.mutex);
935 changed = check_connector_changed(connector);
936 mutex_unlock(&dev->mode_config.mutex);
937
938 if (changed) {
939 drm_kms_helper_connector_hotplug_event(connector);
940 drm_dbg_kms(dev, "[CONNECTOR:%d:%s] Sent hotplug event\n",
941 connector->base.id,
942 connector->name);
943 }
944
945 return changed;
946}
947EXPORT_SYMBOL(drm_connector_helper_hpd_irq_event);
948
949/**
950 * drm_helper_hpd_irq_event - hotplug processing
951 * @dev: drm_device
952 *
953 * Drivers can use this helper function to run a detect cycle on all connectors
954 * which have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All
955 * other connectors are ignored, which is useful to avoid reprobing fixed
956 * panels.
957 *
958 * This helper function is useful for drivers which can't or don't track hotplug
959 * interrupts for each connector.
960 *
961 * Drivers which support hotplug interrupts for each connector individually and
962 * which have a more fine-grained detect logic can use
963 * drm_connector_helper_hpd_irq_event(). Alternatively, they should bypass this
964 * code and directly call drm_kms_helper_hotplug_event() in case the connector
965 * state changed.
966 *
967 * This function must be called from process context with no mode
968 * setting locks held.
969 *
970 * Note that a connector can be both polled and probed from the hotplug handler,
971 * in case the hotplug interrupt is known to be unreliable.
972 *
973 * Returns:
974 * A boolean indicating whether the connector status changed or not
975 */
976bool drm_helper_hpd_irq_event(struct drm_device *dev)
977{
978 struct drm_connector *connector, *first_changed_connector = NULL;
979 struct drm_connector_list_iter conn_iter;
980 int changed = 0;
981
982 if (!dev->mode_config.poll_enabled)
983 return false;
984
985 mutex_lock(&dev->mode_config.mutex);
986 drm_connector_list_iter_begin(dev, &conn_iter);
987 drm_for_each_connector_iter(connector, &conn_iter) {
988 /* Only handle HPD capable connectors. */
989 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
990 continue;
991
992 if (check_connector_changed(connector)) {
993 if (!first_changed_connector) {
994 drm_connector_get(connector);
995 first_changed_connector = connector;
996 }
997
998 changed++;
999 }
1000 }
1001 drm_connector_list_iter_end(&conn_iter);
1002 mutex_unlock(&dev->mode_config.mutex);
1003
1004 if (changed == 1)
1005 drm_kms_helper_connector_hotplug_event(first_changed_connector);
1006 else if (changed > 0)
1007 drm_kms_helper_hotplug_event(dev);
1008
1009 if (first_changed_connector)
1010 drm_connector_put(first_changed_connector);
1011
1012 return changed;
1013}
1014EXPORT_SYMBOL(drm_helper_hpd_irq_event);
1015
1016/**
1017 * drm_crtc_helper_mode_valid_fixed - Validates a display mode
1018 * @crtc: the crtc
1019 * @mode: the mode to validate
1020 * @fixed_mode: the display hardware's mode
1021 *
1022 * Returns:
1023 * MODE_OK on success, or another mode-status code otherwise.
1024 */
1025enum drm_mode_status drm_crtc_helper_mode_valid_fixed(struct drm_crtc *crtc,
1026 const struct drm_display_mode *mode,
1027 const struct drm_display_mode *fixed_mode)
1028{
1029 if (mode->hdisplay != fixed_mode->hdisplay && mode->vdisplay != fixed_mode->vdisplay)
1030 return MODE_ONE_SIZE;
1031 else if (mode->hdisplay != fixed_mode->hdisplay)
1032 return MODE_ONE_WIDTH;
1033 else if (mode->vdisplay != fixed_mode->vdisplay)
1034 return MODE_ONE_HEIGHT;
1035
1036 return MODE_OK;
1037}
1038EXPORT_SYMBOL(drm_crtc_helper_mode_valid_fixed);
1039
1040/**
1041 * drm_connector_helper_get_modes_from_ddc - Updates the connector's EDID
1042 * property from the connector's
1043 * DDC channel
1044 * @connector: The connector
1045 *
1046 * Returns:
1047 * The number of detected display modes.
1048 *
1049 * Uses a connector's DDC channel to retrieve EDID data and update the
1050 * connector's EDID property and display modes. Drivers can use this
1051 * function to implement struct &drm_connector_helper_funcs.get_modes
1052 * for connectors with a DDC channel.
1053 */
1054int drm_connector_helper_get_modes_from_ddc(struct drm_connector *connector)
1055{
1056 struct edid *edid;
1057 int count = 0;
1058
1059 if (!connector->ddc)
1060 return 0;
1061
1062 edid = drm_get_edid(connector, connector->ddc);
1063
1064 // clears property if EDID is NULL
1065 drm_connector_update_edid_property(connector, edid);
1066
1067 if (edid) {
1068 count = drm_add_edid_modes(connector, edid);
1069 kfree(edid);
1070 }
1071
1072 return count;
1073}
1074EXPORT_SYMBOL(drm_connector_helper_get_modes_from_ddc);
1075
1076/**
1077 * drm_connector_helper_get_modes_fixed - Duplicates a display mode for a connector
1078 * @connector: the connector
1079 * @fixed_mode: the display hardware's mode
1080 *
1081 * This function duplicates a display modes for a connector. Drivers for hardware
1082 * that only supports a single fixed mode can use this function in their connector's
1083 * get_modes helper.
1084 *
1085 * Returns:
1086 * The number of created modes.
1087 */
1088int drm_connector_helper_get_modes_fixed(struct drm_connector *connector,
1089 const struct drm_display_mode *fixed_mode)
1090{
1091 struct drm_device *dev = connector->dev;
1092 struct drm_display_mode *mode;
1093
1094 mode = drm_mode_duplicate(dev, fixed_mode);
1095 if (!mode) {
1096 drm_err(dev, "Failed to duplicate mode " DRM_MODE_FMT "\n",
1097 DRM_MODE_ARG(fixed_mode));
1098 return 0;
1099 }
1100
1101 if (mode->name[0] == '\0')
1102 drm_mode_set_name(mode);
1103
1104 mode->type |= DRM_MODE_TYPE_PREFERRED;
1105 drm_mode_probed_add(connector, mode);
1106
1107 if (mode->width_mm)
1108 connector->display_info.width_mm = mode->width_mm;
1109 if (mode->height_mm)
1110 connector->display_info.height_mm = mode->height_mm;
1111
1112 return 1;
1113}
1114EXPORT_SYMBOL(drm_connector_helper_get_modes_fixed);
1115
1116/**
1117 * drm_connector_helper_get_modes - Read EDID and update connector.
1118 * @connector: The connector
1119 *
1120 * Read the EDID using drm_edid_read() (which requires that connector->ddc is
1121 * set), and update the connector using the EDID.
1122 *
1123 * This can be used as the "default" connector helper .get_modes() hook if the
1124 * driver does not need any special processing. This is sets the example what
1125 * custom .get_modes() hooks should do regarding EDID read and connector update.
1126 *
1127 * Returns: Number of modes.
1128 */
1129int drm_connector_helper_get_modes(struct drm_connector *connector)
1130{
1131 const struct drm_edid *drm_edid;
1132 int count;
1133
1134 drm_edid = drm_edid_read(connector);
1135
1136 /*
1137 * Unconditionally update the connector. If the EDID was read
1138 * successfully, fill in the connector information derived from the
1139 * EDID. Otherwise, if the EDID is NULL, clear the connector
1140 * information.
1141 */
1142 count = drm_edid_connector_update(connector, drm_edid);
1143
1144 drm_edid_free(drm_edid);
1145
1146 return count;
1147}
1148EXPORT_SYMBOL(drm_connector_helper_get_modes);