351cbc40f0f8436486d89ac1c8cb0f56a8b56479
[sfrench/cifs-2.6.git] / drivers / gpu / drm / drm_probe_helper.c
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
67 static bool drm_kms_helper_poll = true;
68 module_param_named(poll, drm_kms_helper_poll, bool, 0600);
69
70 static enum drm_mode_status
71 drm_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
89 static enum drm_mode_status
90 drm_mode_validate_pipeline(struct drm_display_mode *mode,
91                             struct drm_connector *connector)
92 {
93         struct drm_device *dev = connector->dev;
94         enum drm_mode_status ret = MODE_OK;
95         struct drm_encoder *encoder;
96         int i;
97
98         /* Step 1: Validate against connector */
99         ret = drm_connector_mode_valid(connector, mode);
100         if (ret != MODE_OK)
101                 return ret;
102
103         /* Step 2: Validate against encoders and crtcs */
104         drm_connector_for_each_possible_encoder(connector, encoder, i) {
105                 struct drm_crtc *crtc;
106
107                 ret = drm_encoder_mode_valid(encoder, mode);
108                 if (ret != MODE_OK) {
109                         /* No point in continuing for crtc check as this encoder
110                          * will not accept the mode anyway. If all encoders
111                          * reject the mode then, at exit, ret will not be
112                          * MODE_OK. */
113                         continue;
114                 }
115
116                 ret = drm_bridge_mode_valid(encoder->bridge, mode);
117                 if (ret != MODE_OK) {
118                         /* There is also no point in continuing for crtc check
119                          * here. */
120                         continue;
121                 }
122
123                 drm_for_each_crtc(crtc, dev) {
124                         if (!drm_encoder_crtc_ok(encoder, crtc))
125                                 continue;
126
127                         ret = drm_crtc_mode_valid(crtc, mode);
128                         if (ret == MODE_OK) {
129                                 /* If we get to this point there is at least
130                                  * one combination of encoder+crtc that works
131                                  * for this mode. Lets return now. */
132                                 return ret;
133                         }
134                 }
135         }
136
137         return ret;
138 }
139
140 static int drm_helper_probe_add_cmdline_mode(struct drm_connector *connector)
141 {
142         struct drm_cmdline_mode *cmdline_mode;
143         struct drm_display_mode *mode;
144
145         cmdline_mode = &connector->cmdline_mode;
146         if (!cmdline_mode->specified)
147                 return 0;
148
149         /* Only add a GTF mode if we find no matching probed modes */
150         list_for_each_entry(mode, &connector->probed_modes, head) {
151                 if (mode->hdisplay != cmdline_mode->xres ||
152                     mode->vdisplay != cmdline_mode->yres)
153                         continue;
154
155                 if (cmdline_mode->refresh_specified) {
156                         /* The probed mode's vrefresh is set until later */
157                         if (drm_mode_vrefresh(mode) != cmdline_mode->refresh)
158                                 continue;
159                 }
160
161                 return 0;
162         }
163
164         mode = drm_mode_create_from_cmdline_mode(connector->dev,
165                                                  cmdline_mode);
166         if (mode == NULL)
167                 return 0;
168
169         drm_mode_probed_add(connector, mode);
170         return 1;
171 }
172
173 enum drm_mode_status drm_crtc_mode_valid(struct drm_crtc *crtc,
174                                          const struct drm_display_mode *mode)
175 {
176         const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
177
178         if (!crtc_funcs || !crtc_funcs->mode_valid)
179                 return MODE_OK;
180
181         return crtc_funcs->mode_valid(crtc, mode);
182 }
183
184 enum drm_mode_status drm_encoder_mode_valid(struct drm_encoder *encoder,
185                                             const struct drm_display_mode *mode)
186 {
187         const struct drm_encoder_helper_funcs *encoder_funcs =
188                 encoder->helper_private;
189
190         if (!encoder_funcs || !encoder_funcs->mode_valid)
191                 return MODE_OK;
192
193         return encoder_funcs->mode_valid(encoder, mode);
194 }
195
196 enum drm_mode_status drm_connector_mode_valid(struct drm_connector *connector,
197                                               struct drm_display_mode *mode)
198 {
199         const struct drm_connector_helper_funcs *connector_funcs =
200                 connector->helper_private;
201
202         if (!connector_funcs || !connector_funcs->mode_valid)
203                 return MODE_OK;
204
205         return connector_funcs->mode_valid(connector, mode);
206 }
207
208 #define DRM_OUTPUT_POLL_PERIOD (10*HZ)
209 /**
210  * drm_kms_helper_poll_enable - re-enable output polling.
211  * @dev: drm_device
212  *
213  * This function re-enables the output polling work, after it has been
214  * temporarily disabled using drm_kms_helper_poll_disable(), for example over
215  * suspend/resume.
216  *
217  * Drivers can call this helper from their device resume implementation. It is
218  * not an error to call this even when output polling isn't enabled.
219  *
220  * Note that calls to enable and disable polling must be strictly ordered, which
221  * is automatically the case when they're only call from suspend/resume
222  * callbacks.
223  */
224 void drm_kms_helper_poll_enable(struct drm_device *dev)
225 {
226         bool poll = false;
227         struct drm_connector *connector;
228         struct drm_connector_list_iter conn_iter;
229         unsigned long delay = DRM_OUTPUT_POLL_PERIOD;
230
231         if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
232                 return;
233
234         drm_connector_list_iter_begin(dev, &conn_iter);
235         drm_for_each_connector_iter(connector, &conn_iter) {
236                 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
237                                          DRM_CONNECTOR_POLL_DISCONNECT))
238                         poll = true;
239         }
240         drm_connector_list_iter_end(&conn_iter);
241
242         if (dev->mode_config.delayed_event) {
243                 /*
244                  * FIXME:
245                  *
246                  * Use short (1s) delay to handle the initial delayed event.
247                  * This delay should not be needed, but Optimus/nouveau will
248                  * fail in a mysterious way if the delayed event is handled as
249                  * soon as possible like it is done in
250                  * drm_helper_probe_single_connector_modes() in case the poll
251                  * was enabled before.
252                  */
253                 poll = true;
254                 delay = HZ;
255         }
256
257         if (poll)
258                 schedule_delayed_work(&dev->mode_config.output_poll_work, delay);
259 }
260 EXPORT_SYMBOL(drm_kms_helper_poll_enable);
261
262 static enum drm_connector_status
263 drm_helper_probe_detect_ctx(struct drm_connector *connector, bool force)
264 {
265         const struct drm_connector_helper_funcs *funcs = connector->helper_private;
266         struct drm_modeset_acquire_ctx ctx;
267         int ret;
268
269         drm_modeset_acquire_init(&ctx, 0);
270
271 retry:
272         ret = drm_modeset_lock(&connector->dev->mode_config.connection_mutex, &ctx);
273         if (!ret) {
274                 if (funcs->detect_ctx)
275                         ret = funcs->detect_ctx(connector, &ctx, force);
276                 else if (connector->funcs->detect)
277                         ret = connector->funcs->detect(connector, force);
278                 else
279                         ret = connector_status_connected;
280         }
281
282         if (ret == -EDEADLK) {
283                 drm_modeset_backoff(&ctx);
284                 goto retry;
285         }
286
287         if (WARN_ON(ret < 0))
288                 ret = connector_status_unknown;
289
290         drm_modeset_drop_locks(&ctx);
291         drm_modeset_acquire_fini(&ctx);
292
293         return ret;
294 }
295
296 /**
297  * drm_helper_probe_detect - probe connector status
298  * @connector: connector to probe
299  * @ctx: acquire_ctx, or NULL to let this function handle locking.
300  * @force: Whether destructive probe operations should be performed.
301  *
302  * This function calls the detect callbacks of the connector.
303  * This function returns &drm_connector_status, or
304  * if @ctx is set, it might also return -EDEADLK.
305  */
306 int
307 drm_helper_probe_detect(struct drm_connector *connector,
308                         struct drm_modeset_acquire_ctx *ctx,
309                         bool force)
310 {
311         const struct drm_connector_helper_funcs *funcs = connector->helper_private;
312         struct drm_device *dev = connector->dev;
313         int ret;
314
315         if (!ctx)
316                 return drm_helper_probe_detect_ctx(connector, force);
317
318         ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
319         if (ret)
320                 return ret;
321
322         if (funcs->detect_ctx)
323                 return funcs->detect_ctx(connector, ctx, force);
324         else if (connector->funcs->detect)
325                 return connector->funcs->detect(connector, force);
326         else
327                 return connector_status_connected;
328 }
329 EXPORT_SYMBOL(drm_helper_probe_detect);
330
331 /**
332  * drm_helper_probe_single_connector_modes - get complete set of display modes
333  * @connector: connector to probe
334  * @maxX: max width for modes
335  * @maxY: max height for modes
336  *
337  * Based on the helper callbacks implemented by @connector in struct
338  * &drm_connector_helper_funcs try to detect all valid modes.  Modes will first
339  * be added to the connector's probed_modes list, then culled (based on validity
340  * and the @maxX, @maxY parameters) and put into the normal modes list.
341  *
342  * Intended to be used as a generic implementation of the
343  * &drm_connector_funcs.fill_modes() vfunc for drivers that use the CRTC helpers
344  * for output mode filtering and detection.
345  *
346  * The basic procedure is as follows
347  *
348  * 1. All modes currently on the connector's modes list are marked as stale
349  *
350  * 2. New modes are added to the connector's probed_modes list with
351  *    drm_mode_probed_add(). New modes start their life with status as OK.
352  *    Modes are added from a single source using the following priority order.
353  *
354  *    - &drm_connector_helper_funcs.get_modes vfunc
355  *    - if the connector status is connector_status_connected, standard
356  *      VESA DMT modes up to 1024x768 are automatically added
357  *      (drm_add_modes_noedid())
358  *
359  *    Finally modes specified via the kernel command line (video=...) are
360  *    added in addition to what the earlier probes produced
361  *    (drm_helper_probe_add_cmdline_mode()). These modes are generated
362  *    using the VESA GTF/CVT formulas.
363  *
364  * 3. Modes are moved from the probed_modes list to the modes list. Potential
365  *    duplicates are merged together (see drm_connector_list_update()).
366  *    After this step the probed_modes list will be empty again.
367  *
368  * 4. Any non-stale mode on the modes list then undergoes validation
369  *
370  *    - drm_mode_validate_basic() performs basic sanity checks
371  *    - drm_mode_validate_size() filters out modes larger than @maxX and @maxY
372  *      (if specified)
373  *    - drm_mode_validate_flag() checks the modes against basic connector
374  *      capabilities (interlace_allowed,doublescan_allowed,stereo_allowed)
375  *    - the optional &drm_connector_helper_funcs.mode_valid helper can perform
376  *      driver and/or sink specific checks
377  *    - the optional &drm_crtc_helper_funcs.mode_valid,
378  *      &drm_bridge_funcs.mode_valid and &drm_encoder_helper_funcs.mode_valid
379  *      helpers can perform driver and/or source specific checks which are also
380  *      enforced by the modeset/atomic helpers
381  *
382  * 5. Any mode whose status is not OK is pruned from the connector's modes list,
383  *    accompanied by a debug message indicating the reason for the mode's
384  *    rejection (see drm_mode_prune_invalid()).
385  *
386  * Returns:
387  * The number of modes found on @connector.
388  */
389 int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
390                                             uint32_t maxX, uint32_t maxY)
391 {
392         struct drm_device *dev = connector->dev;
393         struct drm_display_mode *mode;
394         const struct drm_connector_helper_funcs *connector_funcs =
395                 connector->helper_private;
396         int count = 0, ret;
397         int mode_flags = 0;
398         bool verbose_prune = true;
399         enum drm_connector_status old_status;
400         struct drm_modeset_acquire_ctx ctx;
401
402         WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
403
404         drm_modeset_acquire_init(&ctx, 0);
405
406         DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
407                         connector->name);
408
409 retry:
410         ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx);
411         if (ret == -EDEADLK) {
412                 drm_modeset_backoff(&ctx);
413                 goto retry;
414         } else
415                 WARN_ON(ret < 0);
416
417         /* set all old modes to the stale state */
418         list_for_each_entry(mode, &connector->modes, head)
419                 mode->status = MODE_STALE;
420
421         old_status = connector->status;
422
423         if (connector->force) {
424                 if (connector->force == DRM_FORCE_ON ||
425                     connector->force == DRM_FORCE_ON_DIGITAL)
426                         connector->status = connector_status_connected;
427                 else
428                         connector->status = connector_status_disconnected;
429                 if (connector->funcs->force)
430                         connector->funcs->force(connector);
431         } else {
432                 ret = drm_helper_probe_detect(connector, &ctx, true);
433
434                 if (ret == -EDEADLK) {
435                         drm_modeset_backoff(&ctx);
436                         goto retry;
437                 } else if (WARN(ret < 0, "Invalid return value %i for connector detection\n", ret))
438                         ret = connector_status_unknown;
439
440                 connector->status = ret;
441         }
442
443         /*
444          * Normally either the driver's hpd code or the poll loop should
445          * pick up any changes and fire the hotplug event. But if
446          * userspace sneaks in a probe, we might miss a change. Hence
447          * check here, and if anything changed start the hotplug code.
448          */
449         if (old_status != connector->status) {
450                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
451                               connector->base.id,
452                               connector->name,
453                               drm_get_connector_status_name(old_status),
454                               drm_get_connector_status_name(connector->status));
455
456                 /*
457                  * The hotplug event code might call into the fb
458                  * helpers, and so expects that we do not hold any
459                  * locks. Fire up the poll struct instead, it will
460                  * disable itself again.
461                  */
462                 dev->mode_config.delayed_event = true;
463                 if (dev->mode_config.poll_enabled)
464                         schedule_delayed_work(&dev->mode_config.output_poll_work,
465                                               0);
466         }
467
468         /* Re-enable polling in case the global poll config changed. */
469         if (drm_kms_helper_poll != dev->mode_config.poll_running)
470                 drm_kms_helper_poll_enable(dev);
471
472         dev->mode_config.poll_running = drm_kms_helper_poll;
473
474         if (connector->status == connector_status_disconnected) {
475                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
476                         connector->base.id, connector->name);
477                 drm_connector_update_edid_property(connector, NULL);
478                 verbose_prune = false;
479                 goto prune;
480         }
481
482         count = (*connector_funcs->get_modes)(connector);
483
484         /*
485          * Fallback for when DDC probe failed in drm_get_edid() and thus skipped
486          * override/firmware EDID.
487          */
488         if (count == 0 && connector->status == connector_status_connected)
489                 count = drm_add_override_edid_modes(connector);
490
491         if (count == 0 && connector->status == connector_status_connected)
492                 count = drm_add_modes_noedid(connector, 1024, 768);
493         count += drm_helper_probe_add_cmdline_mode(connector);
494         if (count == 0)
495                 goto prune;
496
497         drm_connector_list_update(connector);
498
499         if (connector->interlace_allowed)
500                 mode_flags |= DRM_MODE_FLAG_INTERLACE;
501         if (connector->doublescan_allowed)
502                 mode_flags |= DRM_MODE_FLAG_DBLSCAN;
503         if (connector->stereo_allowed)
504                 mode_flags |= DRM_MODE_FLAG_3D_MASK;
505
506         list_for_each_entry(mode, &connector->modes, head) {
507                 if (mode->status == MODE_OK)
508                         mode->status = drm_mode_validate_driver(dev, mode);
509
510                 if (mode->status == MODE_OK)
511                         mode->status = drm_mode_validate_size(mode, maxX, maxY);
512
513                 if (mode->status == MODE_OK)
514                         mode->status = drm_mode_validate_flag(mode, mode_flags);
515
516                 if (mode->status == MODE_OK)
517                         mode->status = drm_mode_validate_pipeline(mode,
518                                                                   connector);
519
520                 if (mode->status == MODE_OK)
521                         mode->status = drm_mode_validate_ycbcr420(mode,
522                                                                   connector);
523         }
524
525 prune:
526         drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);
527
528         drm_modeset_drop_locks(&ctx);
529         drm_modeset_acquire_fini(&ctx);
530
531         if (list_empty(&connector->modes))
532                 return 0;
533
534         list_for_each_entry(mode, &connector->modes, head)
535                 mode->vrefresh = drm_mode_vrefresh(mode);
536
537         drm_mode_sort(&connector->modes);
538
539         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
540                         connector->name);
541         list_for_each_entry(mode, &connector->modes, head) {
542                 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
543                 drm_mode_debug_printmodeline(mode);
544         }
545
546         return count;
547 }
548 EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
549
550 /**
551  * drm_kms_helper_hotplug_event - fire off KMS hotplug events
552  * @dev: drm_device whose connector state changed
553  *
554  * This function fires off the uevent for userspace and also calls the
555  * output_poll_changed function, which is most commonly used to inform the fbdev
556  * emulation code and allow it to update the fbcon output configuration.
557  *
558  * Drivers should call this from their hotplug handling code when a change is
559  * detected. Note that this function does not do any output detection of its
560  * own, like drm_helper_hpd_irq_event() does - this is assumed to be done by the
561  * driver already.
562  *
563  * This function must be called from process context with no mode
564  * setting locks held.
565  */
566 void drm_kms_helper_hotplug_event(struct drm_device *dev)
567 {
568         /* send a uevent + call fbdev */
569         drm_sysfs_hotplug_event(dev);
570         if (dev->mode_config.funcs->output_poll_changed)
571                 dev->mode_config.funcs->output_poll_changed(dev);
572
573         drm_client_dev_hotplug(dev);
574 }
575 EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
576
577 static void output_poll_execute(struct work_struct *work)
578 {
579         struct delayed_work *delayed_work = to_delayed_work(work);
580         struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
581         struct drm_connector *connector;
582         struct drm_connector_list_iter conn_iter;
583         enum drm_connector_status old_status;
584         bool repoll = false, changed;
585
586         if (!dev->mode_config.poll_enabled)
587                 return;
588
589         /* Pick up any changes detected by the probe functions. */
590         changed = dev->mode_config.delayed_event;
591         dev->mode_config.delayed_event = false;
592
593         if (!drm_kms_helper_poll)
594                 goto out;
595
596         if (!mutex_trylock(&dev->mode_config.mutex)) {
597                 repoll = true;
598                 goto out;
599         }
600
601         drm_connector_list_iter_begin(dev, &conn_iter);
602         drm_for_each_connector_iter(connector, &conn_iter) {
603                 /* Ignore forced connectors. */
604                 if (connector->force)
605                         continue;
606
607                 /* Ignore HPD capable connectors and connectors where we don't
608                  * want any hotplug detection at all for polling. */
609                 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
610                         continue;
611
612                 old_status = connector->status;
613                 /* if we are connected and don't want to poll for disconnect
614                    skip it */
615                 if (old_status == connector_status_connected &&
616                     !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
617                         continue;
618
619                 repoll = true;
620
621                 connector->status = drm_helper_probe_detect(connector, NULL, false);
622                 if (old_status != connector->status) {
623                         const char *old, *new;
624
625                         /*
626                          * The poll work sets force=false when calling detect so
627                          * that drivers can avoid to do disruptive tests (e.g.
628                          * when load detect cycles could cause flickering on
629                          * other, running displays). This bears the risk that we
630                          * flip-flop between unknown here in the poll work and
631                          * the real state when userspace forces a full detect
632                          * call after receiving a hotplug event due to this
633                          * change.
634                          *
635                          * Hence clamp an unknown detect status to the old
636                          * value.
637                          */
638                         if (connector->status == connector_status_unknown) {
639                                 connector->status = old_status;
640                                 continue;
641                         }
642
643                         old = drm_get_connector_status_name(old_status);
644                         new = drm_get_connector_status_name(connector->status);
645
646                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] "
647                                       "status updated from %s to %s\n",
648                                       connector->base.id,
649                                       connector->name,
650                                       old, new);
651
652                         changed = true;
653                 }
654         }
655         drm_connector_list_iter_end(&conn_iter);
656
657         mutex_unlock(&dev->mode_config.mutex);
658
659 out:
660         if (changed)
661                 drm_kms_helper_hotplug_event(dev);
662
663         if (repoll)
664                 schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
665 }
666
667 /**
668  * drm_kms_helper_is_poll_worker - is %current task an output poll worker?
669  *
670  * Determine if %current task is an output poll worker.  This can be used
671  * to select distinct code paths for output polling versus other contexts.
672  *
673  * One use case is to avoid a deadlock between the output poll worker and
674  * the autosuspend worker wherein the latter waits for polling to finish
675  * upon calling drm_kms_helper_poll_disable(), while the former waits for
676  * runtime suspend to finish upon calling pm_runtime_get_sync() in a
677  * connector ->detect hook.
678  */
679 bool drm_kms_helper_is_poll_worker(void)
680 {
681         struct work_struct *work = current_work();
682
683         return work && work->func == output_poll_execute;
684 }
685 EXPORT_SYMBOL(drm_kms_helper_is_poll_worker);
686
687 /**
688  * drm_kms_helper_poll_disable - disable output polling
689  * @dev: drm_device
690  *
691  * This function disables the output polling work.
692  *
693  * Drivers can call this helper from their device suspend implementation. It is
694  * not an error to call this even when output polling isn't enabled or already
695  * disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable().
696  *
697  * Note that calls to enable and disable polling must be strictly ordered, which
698  * is automatically the case when they're only call from suspend/resume
699  * callbacks.
700  */
701 void drm_kms_helper_poll_disable(struct drm_device *dev)
702 {
703         if (!dev->mode_config.poll_enabled)
704                 return;
705         cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
706 }
707 EXPORT_SYMBOL(drm_kms_helper_poll_disable);
708
709 /**
710  * drm_kms_helper_poll_init - initialize and enable output polling
711  * @dev: drm_device
712  *
713  * This function intializes and then also enables output polling support for
714  * @dev. Drivers which do not have reliable hotplug support in hardware can use
715  * this helper infrastructure to regularly poll such connectors for changes in
716  * their connection state.
717  *
718  * Drivers can control which connectors are polled by setting the
719  * DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On
720  * connectors where probing live outputs can result in visual distortion drivers
721  * should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this.
722  * Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are
723  * completely ignored by the polling logic.
724  *
725  * Note that a connector can be both polled and probed from the hotplug handler,
726  * in case the hotplug interrupt is known to be unreliable.
727  */
728 void drm_kms_helper_poll_init(struct drm_device *dev)
729 {
730         INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
731         dev->mode_config.poll_enabled = true;
732
733         drm_kms_helper_poll_enable(dev);
734 }
735 EXPORT_SYMBOL(drm_kms_helper_poll_init);
736
737 /**
738  * drm_kms_helper_poll_fini - disable output polling and clean it up
739  * @dev: drm_device
740  */
741 void drm_kms_helper_poll_fini(struct drm_device *dev)
742 {
743         if (!dev->mode_config.poll_enabled)
744                 return;
745
746         dev->mode_config.poll_enabled = false;
747         cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
748 }
749 EXPORT_SYMBOL(drm_kms_helper_poll_fini);
750
751 /**
752  * drm_helper_hpd_irq_event - hotplug processing
753  * @dev: drm_device
754  *
755  * Drivers can use this helper function to run a detect cycle on all connectors
756  * which have the DRM_CONNECTOR_POLL_HPD flag set in their &polled member. All
757  * other connectors are ignored, which is useful to avoid reprobing fixed
758  * panels.
759  *
760  * This helper function is useful for drivers which can't or don't track hotplug
761  * interrupts for each connector.
762  *
763  * Drivers which support hotplug interrupts for each connector individually and
764  * which have a more fine-grained detect logic should bypass this code and
765  * directly call drm_kms_helper_hotplug_event() in case the connector state
766  * changed.
767  *
768  * This function must be called from process context with no mode
769  * setting locks held.
770  *
771  * Note that a connector can be both polled and probed from the hotplug handler,
772  * in case the hotplug interrupt is known to be unreliable.
773  */
774 bool drm_helper_hpd_irq_event(struct drm_device *dev)
775 {
776         struct drm_connector *connector;
777         struct drm_connector_list_iter conn_iter;
778         enum drm_connector_status old_status;
779         bool changed = false;
780
781         if (!dev->mode_config.poll_enabled)
782                 return false;
783
784         mutex_lock(&dev->mode_config.mutex);
785         drm_connector_list_iter_begin(dev, &conn_iter);
786         drm_for_each_connector_iter(connector, &conn_iter) {
787                 /* Only handle HPD capable connectors. */
788                 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
789                         continue;
790
791                 old_status = connector->status;
792
793                 connector->status = drm_helper_probe_detect(connector, NULL, false);
794                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
795                               connector->base.id,
796                               connector->name,
797                               drm_get_connector_status_name(old_status),
798                               drm_get_connector_status_name(connector->status));
799                 if (old_status != connector->status)
800                         changed = true;
801         }
802         drm_connector_list_iter_end(&conn_iter);
803         mutex_unlock(&dev->mode_config.mutex);
804
805         if (changed)
806                 drm_kms_helper_hotplug_event(dev);
807
808         return changed;
809 }
810 EXPORT_SYMBOL(drm_helper_hpd_irq_event);