Subversion Repositories Kolibri OS

Rev

Rev 4075 | Rev 4126 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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