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