i915_drv.c 30.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/* i915_drv.c -- i830,i845,i855,i865,i915 driver -*- linux-c -*-
 */
D
Dave Airlie 已提交
3
/*
4
 *
L
Linus Torvalds 已提交
5 6
 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
 * All Rights Reserved.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
D
Dave Airlie 已提交
28
 */
L
Linus Torvalds 已提交
29

30
#include <linux/device.h>
31 32
#include <drm/drmP.h>
#include <drm/i915_drm.h>
L
Linus Torvalds 已提交
33
#include "i915_drv.h"
34
#include "i915_trace.h"
35
#include "intel_drv.h"
L
Linus Torvalds 已提交
36

J
Jesse Barnes 已提交
37
#include <linux/console.h>
38
#include <linux/module.h>
39
#include <drm/drm_crtc_helper.h>
J
Jesse Barnes 已提交
40

41 42
static struct drm_driver driver;

43 44 45 46 47 48 49 50 51 52
#define GEN_DEFAULT_PIPEOFFSETS \
	.pipe_offsets = { PIPE_A_OFFSET, PIPE_B_OFFSET, \
			  PIPE_C_OFFSET, PIPE_EDP_OFFSET }, \
	.trans_offsets = { TRANSCODER_A_OFFSET, TRANSCODER_B_OFFSET, \
			   TRANSCODER_C_OFFSET, TRANSCODER_EDP_OFFSET }, \
	.dpll_offsets = { DPLL_A_OFFSET, DPLL_B_OFFSET }, \
	.dpll_md_offsets = { DPLL_A_MD_OFFSET, DPLL_B_MD_OFFSET }, \
	.palette_offsets = { PALETTE_A_OFFSET, PALETTE_B_OFFSET }


53
static const struct intel_device_info intel_i830_info = {
54
	.gen = 2, .is_mobile = 1, .cursor_needs_physical = 1, .num_pipes = 2,
55
	.has_overlay = 1, .overlay_needs_physical = 1,
56
	.ring_mask = RENDER_RING,
57
	GEN_DEFAULT_PIPEOFFSETS,
58 59
};

60
static const struct intel_device_info intel_845g_info = {
61
	.gen = 2, .num_pipes = 1,
62
	.has_overlay = 1, .overlay_needs_physical = 1,
63
	.ring_mask = RENDER_RING,
64
	GEN_DEFAULT_PIPEOFFSETS,
65 66
};

67
static const struct intel_device_info intel_i85x_info = {
68
	.gen = 2, .is_i85x = 1, .is_mobile = 1, .num_pipes = 2,
69
	.cursor_needs_physical = 1,
70
	.has_overlay = 1, .overlay_needs_physical = 1,
71
	.has_fbc = 1,
72
	.ring_mask = RENDER_RING,
73
	GEN_DEFAULT_PIPEOFFSETS,
74 75
};

76
static const struct intel_device_info intel_i865g_info = {
77
	.gen = 2, .num_pipes = 1,
78
	.has_overlay = 1, .overlay_needs_physical = 1,
79
	.ring_mask = RENDER_RING,
80
	GEN_DEFAULT_PIPEOFFSETS,
81 82
};

83
static const struct intel_device_info intel_i915g_info = {
84
	.gen = 3, .is_i915g = 1, .cursor_needs_physical = 1, .num_pipes = 2,
85
	.has_overlay = 1, .overlay_needs_physical = 1,
86
	.ring_mask = RENDER_RING,
87
	GEN_DEFAULT_PIPEOFFSETS,
88
};
89
static const struct intel_device_info intel_i915gm_info = {
90
	.gen = 3, .is_mobile = 1, .num_pipes = 2,
91
	.cursor_needs_physical = 1,
92
	.has_overlay = 1, .overlay_needs_physical = 1,
93
	.supports_tv = 1,
94
	.has_fbc = 1,
95
	.ring_mask = RENDER_RING,
96
	GEN_DEFAULT_PIPEOFFSETS,
97
};
98
static const struct intel_device_info intel_i945g_info = {
99
	.gen = 3, .has_hotplug = 1, .cursor_needs_physical = 1, .num_pipes = 2,
100
	.has_overlay = 1, .overlay_needs_physical = 1,
101
	.ring_mask = RENDER_RING,
102
	GEN_DEFAULT_PIPEOFFSETS,
103
};
104
static const struct intel_device_info intel_i945gm_info = {
105
	.gen = 3, .is_i945gm = 1, .is_mobile = 1, .num_pipes = 2,
106
	.has_hotplug = 1, .cursor_needs_physical = 1,
107
	.has_overlay = 1, .overlay_needs_physical = 1,
108
	.supports_tv = 1,
109
	.has_fbc = 1,
110
	.ring_mask = RENDER_RING,
111
	GEN_DEFAULT_PIPEOFFSETS,
112 113
};

114
static const struct intel_device_info intel_i965g_info = {
115
	.gen = 4, .is_broadwater = 1, .num_pipes = 2,
116
	.has_hotplug = 1,
117
	.has_overlay = 1,
118
	.ring_mask = RENDER_RING,
119
	GEN_DEFAULT_PIPEOFFSETS,
120 121
};

122
static const struct intel_device_info intel_i965gm_info = {
123
	.gen = 4, .is_crestline = 1, .num_pipes = 2,
124
	.is_mobile = 1, .has_fbc = 1, .has_hotplug = 1,
125
	.has_overlay = 1,
126
	.supports_tv = 1,
127
	.ring_mask = RENDER_RING,
128
	GEN_DEFAULT_PIPEOFFSETS,
129 130
};

131
static const struct intel_device_info intel_g33_info = {
132
	.gen = 3, .is_g33 = 1, .num_pipes = 2,
133
	.need_gfx_hws = 1, .has_hotplug = 1,
134
	.has_overlay = 1,
135
	.ring_mask = RENDER_RING,
136
	GEN_DEFAULT_PIPEOFFSETS,
137 138
};

139
static const struct intel_device_info intel_g45_info = {
140
	.gen = 4, .is_g4x = 1, .need_gfx_hws = 1, .num_pipes = 2,
141
	.has_pipe_cxsr = 1, .has_hotplug = 1,
142
	.ring_mask = RENDER_RING | BSD_RING,
143
	GEN_DEFAULT_PIPEOFFSETS,
144 145
};

146
static const struct intel_device_info intel_gm45_info = {
147
	.gen = 4, .is_g4x = 1, .num_pipes = 2,
148
	.is_mobile = 1, .need_gfx_hws = 1, .has_fbc = 1,
149
	.has_pipe_cxsr = 1, .has_hotplug = 1,
150
	.supports_tv = 1,
151
	.ring_mask = RENDER_RING | BSD_RING,
152
	GEN_DEFAULT_PIPEOFFSETS,
153 154
};

155
static const struct intel_device_info intel_pineview_info = {
156
	.gen = 3, .is_g33 = 1, .is_pineview = 1, .is_mobile = 1, .num_pipes = 2,
157
	.need_gfx_hws = 1, .has_hotplug = 1,
158
	.has_overlay = 1,
159
	GEN_DEFAULT_PIPEOFFSETS,
160 161
};

162
static const struct intel_device_info intel_ironlake_d_info = {
163
	.gen = 5, .num_pipes = 2,
164
	.need_gfx_hws = 1, .has_hotplug = 1,
165
	.ring_mask = RENDER_RING | BSD_RING,
166
	GEN_DEFAULT_PIPEOFFSETS,
167 168
};

169
static const struct intel_device_info intel_ironlake_m_info = {
170
	.gen = 5, .is_mobile = 1, .num_pipes = 2,
171
	.need_gfx_hws = 1, .has_hotplug = 1,
172
	.has_fbc = 1,
173
	.ring_mask = RENDER_RING | BSD_RING,
174
	GEN_DEFAULT_PIPEOFFSETS,
175 176
};

177
static const struct intel_device_info intel_sandybridge_d_info = {
178
	.gen = 6, .num_pipes = 2,
179
	.need_gfx_hws = 1, .has_hotplug = 1,
180
	.has_fbc = 1,
181
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING,
182
	.has_llc = 1,
183
	GEN_DEFAULT_PIPEOFFSETS,
184 185
};

186
static const struct intel_device_info intel_sandybridge_m_info = {
187
	.gen = 6, .is_mobile = 1, .num_pipes = 2,
188
	.need_gfx_hws = 1, .has_hotplug = 1,
189
	.has_fbc = 1,
190
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING,
191
	.has_llc = 1,
192
	GEN_DEFAULT_PIPEOFFSETS,
193 194
};

195 196 197
#define GEN7_FEATURES  \
	.gen = 7, .num_pipes = 3, \
	.need_gfx_hws = 1, .has_hotplug = 1, \
198
	.has_fbc = 1, \
199
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING, \
200
	.has_llc = 1
201

202
static const struct intel_device_info intel_ivybridge_d_info = {
203 204
	GEN7_FEATURES,
	.is_ivybridge = 1,
205
	GEN_DEFAULT_PIPEOFFSETS,
206 207 208
};

static const struct intel_device_info intel_ivybridge_m_info = {
209 210 211
	GEN7_FEATURES,
	.is_ivybridge = 1,
	.is_mobile = 1,
212
	GEN_DEFAULT_PIPEOFFSETS,
213 214
};

215 216 217 218
static const struct intel_device_info intel_ivybridge_q_info = {
	GEN7_FEATURES,
	.is_ivybridge = 1,
	.num_pipes = 0, /* legal, last one wins */
219
	GEN_DEFAULT_PIPEOFFSETS,
220 221
};

222
static const struct intel_device_info intel_valleyview_m_info = {
223 224 225
	GEN7_FEATURES,
	.is_mobile = 1,
	.num_pipes = 2,
226
	.is_valleyview = 1,
227
	.display_mmio_offset = VLV_DISPLAY_BASE,
228
	.has_fbc = 0, /* legal, last one wins */
B
Ben Widawsky 已提交
229
	.has_llc = 0, /* legal, last one wins */
230
	GEN_DEFAULT_PIPEOFFSETS,
231 232 233
};

static const struct intel_device_info intel_valleyview_d_info = {
234 235
	GEN7_FEATURES,
	.num_pipes = 2,
236
	.is_valleyview = 1,
237
	.display_mmio_offset = VLV_DISPLAY_BASE,
238
	.has_fbc = 0, /* legal, last one wins */
B
Ben Widawsky 已提交
239
	.has_llc = 0, /* legal, last one wins */
240
	GEN_DEFAULT_PIPEOFFSETS,
241 242
};

243
static const struct intel_device_info intel_haswell_d_info = {
244 245
	GEN7_FEATURES,
	.is_haswell = 1,
246
	.has_ddi = 1,
247
	.has_fpga_dbg = 1,
248
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING | VEBOX_RING,
249
	GEN_DEFAULT_PIPEOFFSETS,
250 251 252
};

static const struct intel_device_info intel_haswell_m_info = {
253 254 255
	GEN7_FEATURES,
	.is_haswell = 1,
	.is_mobile = 1,
256
	.has_ddi = 1,
257
	.has_fpga_dbg = 1,
258
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING | VEBOX_RING,
259
	GEN_DEFAULT_PIPEOFFSETS,
260 261
};

B
Ben Widawsky 已提交
262
static const struct intel_device_info intel_broadwell_d_info = {
263
	.gen = 8, .num_pipes = 3,
B
Ben Widawsky 已提交
264 265 266 267
	.need_gfx_hws = 1, .has_hotplug = 1,
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING | VEBOX_RING,
	.has_llc = 1,
	.has_ddi = 1,
B
Ben Widawsky 已提交
268
	.has_fbc = 1,
269
	GEN_DEFAULT_PIPEOFFSETS,
B
Ben Widawsky 已提交
270 271 272
};

static const struct intel_device_info intel_broadwell_m_info = {
273
	.gen = 8, .is_mobile = 1, .num_pipes = 3,
B
Ben Widawsky 已提交
274 275 276 277
	.need_gfx_hws = 1, .has_hotplug = 1,
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING | VEBOX_RING,
	.has_llc = 1,
	.has_ddi = 1,
B
Ben Widawsky 已提交
278
	.has_fbc = 1,
279
	GEN_DEFAULT_PIPEOFFSETS,
B
Ben Widawsky 已提交
280 281
};

282 283 284
static const struct intel_device_info intel_broadwell_gt3d_info = {
	.gen = 8, .num_pipes = 3,
	.need_gfx_hws = 1, .has_hotplug = 1,
285
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING | VEBOX_RING | BSD2_RING,
286 287 288 289 290 291 292 293 294
	.has_llc = 1,
	.has_ddi = 1,
	.has_fbc = 1,
	GEN_DEFAULT_PIPEOFFSETS,
};

static const struct intel_device_info intel_broadwell_gt3m_info = {
	.gen = 8, .is_mobile = 1, .num_pipes = 3,
	.need_gfx_hws = 1, .has_hotplug = 1,
295
	.ring_mask = RENDER_RING | BSD_RING | BLT_RING | VEBOX_RING | BSD2_RING,
296 297 298 299 300 301
	.has_llc = 1,
	.has_ddi = 1,
	.has_fbc = 1,
	GEN_DEFAULT_PIPEOFFSETS,
};

302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
/*
 * Make sure any device matches here are from most specific to most
 * general.  For example, since the Quanta match is based on the subsystem
 * and subvendor IDs, we need it to come before the more general IVB
 * PCI ID matches, otherwise we'll use the wrong info struct above.
 */
#define INTEL_PCI_IDS \
	INTEL_I830_IDS(&intel_i830_info),	\
	INTEL_I845G_IDS(&intel_845g_info),	\
	INTEL_I85X_IDS(&intel_i85x_info),	\
	INTEL_I865G_IDS(&intel_i865g_info),	\
	INTEL_I915G_IDS(&intel_i915g_info),	\
	INTEL_I915GM_IDS(&intel_i915gm_info),	\
	INTEL_I945G_IDS(&intel_i945g_info),	\
	INTEL_I945GM_IDS(&intel_i945gm_info),	\
	INTEL_I965G_IDS(&intel_i965g_info),	\
	INTEL_G33_IDS(&intel_g33_info),		\
	INTEL_I965GM_IDS(&intel_i965gm_info),	\
	INTEL_GM45_IDS(&intel_gm45_info), 	\
	INTEL_G45_IDS(&intel_g45_info), 	\
	INTEL_PINEVIEW_IDS(&intel_pineview_info),	\
	INTEL_IRONLAKE_D_IDS(&intel_ironlake_d_info),	\
	INTEL_IRONLAKE_M_IDS(&intel_ironlake_m_info),	\
	INTEL_SNB_D_IDS(&intel_sandybridge_d_info),	\
	INTEL_SNB_M_IDS(&intel_sandybridge_m_info),	\
	INTEL_IVB_Q_IDS(&intel_ivybridge_q_info), /* must be first IVB */ \
	INTEL_IVB_M_IDS(&intel_ivybridge_m_info),	\
	INTEL_IVB_D_IDS(&intel_ivybridge_d_info),	\
	INTEL_HSW_D_IDS(&intel_haswell_d_info), \
	INTEL_HSW_M_IDS(&intel_haswell_m_info), \
	INTEL_VLV_M_IDS(&intel_valleyview_m_info),	\
B
Ben Widawsky 已提交
333
	INTEL_VLV_D_IDS(&intel_valleyview_d_info),	\
334 335 336 337
	INTEL_BDW_GT12M_IDS(&intel_broadwell_m_info),	\
	INTEL_BDW_GT12D_IDS(&intel_broadwell_d_info),	\
	INTEL_BDW_GT3M_IDS(&intel_broadwell_gt3m_info),	\
	INTEL_BDW_GT3D_IDS(&intel_broadwell_gt3d_info)
338

339
static const struct pci_device_id pciidlist[] = {		/* aka */
340
	INTEL_PCI_IDS,
341
	{0, 0, 0}
L
Linus Torvalds 已提交
342 343
};

J
Jesse Barnes 已提交
344 345 346 347
#if defined(CONFIG_DRM_I915_KMS)
MODULE_DEVICE_TABLE(pci, pciidlist);
#endif

348
void intel_detect_pch(struct drm_device *dev)
349 350
{
	struct drm_i915_private *dev_priv = dev->dev_private;
351
	struct pci_dev *pch = NULL;
352

B
Ben Widawsky 已提交
353 354 355 356 357 358 359 360
	/* In all current cases, num_pipes is equivalent to the PCH_NOP setting
	 * (which really amounts to a PCH but no South Display).
	 */
	if (INTEL_INFO(dev)->num_pipes == 0) {
		dev_priv->pch_type = PCH_NOP;
		return;
	}

361 362 363 364 365
	/*
	 * The reason to probe ISA bridge instead of Dev31:Fun0 is to
	 * make graphics device passthrough work easy for VMM, that only
	 * need to expose ISA bridge to let driver know the real hardware
	 * underneath. This is a requirement from virtualization team.
366 367 368 369 370
	 *
	 * In some virtualized environments (e.g. XEN), there is irrelevant
	 * ISA bridge in the system. To work reliably, we should scan trhough
	 * all the ISA bridge devices and check for the first match, instead
	 * of only checking the first one.
371
	 */
372
	while ((pch = pci_get_class(PCI_CLASS_BRIDGE_ISA << 8, pch))) {
373
		if (pch->vendor == PCI_VENDOR_ID_INTEL) {
374
			unsigned short id = pch->device & INTEL_PCH_DEVICE_ID_MASK;
375
			dev_priv->pch_id = id;
376

377 378 379
			if (id == INTEL_PCH_IBX_DEVICE_ID_TYPE) {
				dev_priv->pch_type = PCH_IBX;
				DRM_DEBUG_KMS("Found Ibex Peak PCH\n");
380
				WARN_ON(!IS_GEN5(dev));
381
			} else if (id == INTEL_PCH_CPT_DEVICE_ID_TYPE) {
382 383
				dev_priv->pch_type = PCH_CPT;
				DRM_DEBUG_KMS("Found CougarPoint PCH\n");
384
				WARN_ON(!(IS_GEN6(dev) || IS_IVYBRIDGE(dev)));
J
Jesse Barnes 已提交
385 386 387
			} else if (id == INTEL_PCH_PPT_DEVICE_ID_TYPE) {
				/* PantherPoint is CPT compatible */
				dev_priv->pch_type = PCH_CPT;
388
				DRM_DEBUG_KMS("Found PantherPoint PCH\n");
389
				WARN_ON(!(IS_GEN6(dev) || IS_IVYBRIDGE(dev)));
390 391 392
			} else if (id == INTEL_PCH_LPT_DEVICE_ID_TYPE) {
				dev_priv->pch_type = PCH_LPT;
				DRM_DEBUG_KMS("Found LynxPoint PCH\n");
393
				WARN_ON(!IS_HASWELL(dev));
394
				WARN_ON(IS_ULT(dev));
395 396 397 398 399 400
			} else if (IS_BROADWELL(dev)) {
				dev_priv->pch_type = PCH_LPT;
				dev_priv->pch_id =
					INTEL_PCH_LPT_LP_DEVICE_ID_TYPE;
				DRM_DEBUG_KMS("This is Broadwell, assuming "
					      "LynxPoint LP PCH\n");
401 402 403 404 405
			} else if (id == INTEL_PCH_LPT_LP_DEVICE_ID_TYPE) {
				dev_priv->pch_type = PCH_LPT;
				DRM_DEBUG_KMS("Found LynxPoint LP PCH\n");
				WARN_ON(!IS_HASWELL(dev));
				WARN_ON(!IS_ULT(dev));
406 407 408
			} else
				continue;

409
			break;
410 411
		}
	}
412
	if (!pch)
413 414 415
		DRM_DEBUG_KMS("No PCH found.\n");

	pci_dev_put(pch);
416 417
}

418 419 420
bool i915_semaphore_is_enabled(struct drm_device *dev)
{
	if (INTEL_INFO(dev)->gen < 6)
421
		return false;
422

423 424
	if (i915.semaphores >= 0)
		return i915.semaphores;
425

426 427 428 429
	/* Until we get further testing... */
	if (IS_GEN8(dev))
		return false;

430
#ifdef CONFIG_INTEL_IOMMU
431
	/* Enable semaphores on SNB when IO remapping is off */
432 433 434
	if (INTEL_INFO(dev)->gen == 6 && intel_iommu_gfx_mapped)
		return false;
#endif
435

436
	return true;
437 438
}

439
static int i915_drm_freeze(struct drm_device *dev)
J
Jesse Barnes 已提交
440
{
441
	struct drm_i915_private *dev_priv = dev->dev_private;
442
	struct drm_crtc *crtc;
443

444 445
	intel_runtime_pm_get(dev_priv);

446 447 448 449 450
	/* ignore lid events during suspend */
	mutex_lock(&dev_priv->modeset_restore_lock);
	dev_priv->modeset_restore = MODESET_SUSPENDED;
	mutex_unlock(&dev_priv->modeset_restore_lock);

451 452
	/* We do a lot of poking in a lot of registers, make sure they work
	 * properly. */
453
	intel_display_set_init_power(dev_priv, true);
454

455 456
	drm_kms_helper_poll_disable(dev);

J
Jesse Barnes 已提交
457 458
	pci_save_state(dev->pdev);

459
	/* If KMS is active, we do the leavevt stuff here */
460
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
461 462
		int error;

463
		error = i915_gem_suspend(dev);
464
		if (error) {
465
			dev_err(&dev->pdev->dev,
466 467 468
				"GEM idle failed, resume might fail\n");
			return error;
		}
469

470 471
		cancel_delayed_work_sync(&dev_priv->rps.delayed_resume_work);

472
		drm_irq_uninstall(dev);
473
		dev_priv->enable_hotplug_processing = false;
474 475 476 477
		/*
		 * Disable CRTCs directly since we want to preserve sw state
		 * for _thaw.
		 */
478
		mutex_lock(&dev->mode_config.mutex);
479 480
		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
			dev_priv->display.crtc_disable(crtc);
481
		mutex_unlock(&dev->mode_config.mutex);
482 483

		intel_modeset_suspend_hw(dev);
484 485
	}

486 487
	i915_gem_suspend_gtt_mappings(dev);

488 489
	i915_save_state(dev);

490
	intel_opregion_fini(dev);
491
	intel_uncore_fini(dev);
492

493
	console_lock();
494
	intel_fbdev_set_suspend(dev, FBINFO_STATE_SUSPENDED);
495 496
	console_unlock();

497 498
	dev_priv->suspend_count++;

499
	return 0;
500 501
}

502
int i915_suspend(struct drm_device *dev, pm_message_t state)
503 504 505 506 507 508 509 510 511 512 513 514
{
	int error;

	if (!dev || !dev->dev_private) {
		DRM_ERROR("dev: %p\n", dev);
		DRM_ERROR("DRM not initialized, aborting suspend.\n");
		return -ENODEV;
	}

	if (state.event == PM_EVENT_PRETHAW)
		return 0;

515 516 517

	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;
518

519 520 521 522
	error = i915_drm_freeze(dev);
	if (error)
		return error;

523 524 525 526 527
	if (state.event == PM_EVENT_SUSPEND) {
		/* Shut down the device */
		pci_disable_device(dev->pdev);
		pci_set_power_state(dev->pdev, PCI_D3hot);
	}
J
Jesse Barnes 已提交
528 529 530 531

	return 0;
}

532 533 534 535 536 537 538 539
void intel_console_resume(struct work_struct *work)
{
	struct drm_i915_private *dev_priv =
		container_of(work, struct drm_i915_private,
			     console_resume_work);
	struct drm_device *dev = dev_priv->dev;

	console_lock();
540
	intel_fbdev_set_suspend(dev, FBINFO_STATE_RUNNING);
541 542 543
	console_unlock();
}

544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
static void intel_resume_hotplug(struct drm_device *dev)
{
	struct drm_mode_config *mode_config = &dev->mode_config;
	struct intel_encoder *encoder;

	mutex_lock(&mode_config->mutex);
	DRM_DEBUG_KMS("running encoder hotplug functions\n");

	list_for_each_entry(encoder, &mode_config->encoder_list, base.head)
		if (encoder->hot_plug)
			encoder->hot_plug(encoder);

	mutex_unlock(&mode_config->mutex);

	/* Just fire off a uevent and let userspace tell us what to do */
	drm_helper_hpd_irq_event(dev);
}

562
static int i915_drm_thaw_early(struct drm_device *dev)
J
Jesse Barnes 已提交
563
{
564
	struct drm_i915_private *dev_priv = dev->dev_private;
565

566
	intel_uncore_early_sanitize(dev);
567
	intel_uncore_sanitize(dev);
568 569 570 571 572 573 574 575
	intel_power_domains_init_hw(dev_priv);

	return 0;
}

static int __i915_drm_thaw(struct drm_device *dev, bool restore_gtt_mappings)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
576 577 578 579 580 581 582 583

	if (drm_core_check_feature(dev, DRIVER_MODESET) &&
	    restore_gtt_mappings) {
		mutex_lock(&dev->struct_mutex);
		i915_gem_restore_gtt_mappings(dev);
		mutex_unlock(&dev->struct_mutex);
	}

584
	i915_restore_state(dev);
585
	intel_opregion_setup(dev);
586

587 588
	/* KMS EnterVT equivalent */
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
P
Paulo Zanoni 已提交
589
		intel_init_pch_refclk(dev);
590
		drm_mode_config_reset(dev);
591

592
		mutex_lock(&dev->struct_mutex);
593 594 595 596
		if (i915_gem_init_hw(dev)) {
			DRM_ERROR("failed to re-initialize GPU, declaring wedged!\n");
			atomic_set_mask(I915_WEDGED, &dev_priv->gpu_error.reset_counter);
		}
597
		mutex_unlock(&dev->struct_mutex);
598

599
		/* We need working interrupts for modeset enabling ... */
600
		drm_irq_install(dev, dev->pdev->irq);
601

602
		intel_modeset_init_hw(dev);
603 604 605 606

		drm_modeset_lock_all(dev);
		intel_modeset_setup_hw_state(dev, true);
		drm_modeset_unlock_all(dev);
607 608 609 610 611 612 613

		/*
		 * ... but also need to make sure that hotplug processing
		 * doesn't cause havoc. Like in the driver load code we don't
		 * bother with the tiny race here where we might loose hotplug
		 * notifications.
		 * */
614
		intel_hpd_init(dev);
615
		dev_priv->enable_hotplug_processing = true;
616 617
		/* Config may have changed between suspend and resume */
		intel_resume_hotplug(dev);
J
Jesse Barnes 已提交
618
	}
619

620 621
	intel_opregion_init(dev);

622 623 624 625 626 627
	/*
	 * The console lock can be pretty contented on resume due
	 * to all the printk activity.  Try to keep it out of the hot
	 * path of resume if possible.
	 */
	if (console_trylock()) {
628
		intel_fbdev_set_suspend(dev, FBINFO_STATE_RUNNING);
629 630 631 632 633
		console_unlock();
	} else {
		schedule_work(&dev_priv->console_resume_work);
	}

634 635 636
	mutex_lock(&dev_priv->modeset_restore_lock);
	dev_priv->modeset_restore = MODESET_DONE;
	mutex_unlock(&dev_priv->modeset_restore_lock);
637 638

	intel_runtime_pm_put(dev_priv);
639
	return 0;
640 641
}

642 643
static int i915_drm_thaw(struct drm_device *dev)
{
644
	if (drm_core_check_feature(dev, DRIVER_MODESET))
645
		i915_check_and_clear_faults(dev);
646

647
	return __i915_drm_thaw(dev, true);
648 649
}

650
static int i915_resume_early(struct drm_device *dev)
651
{
652 653 654
	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;

655 656 657 658 659 660 661 662 663
	/*
	 * We have a resume ordering issue with the snd-hda driver also
	 * requiring our device to be power up. Due to the lack of a
	 * parent/child relationship we currently solve this with an early
	 * resume hook.
	 *
	 * FIXME: This should be solved with a special hdmi sink device or
	 * similar so that power domains can be employed.
	 */
664 665 666 667 668
	if (pci_enable_device(dev->pdev))
		return -EIO;

	pci_set_master(dev->pdev);

669 670 671 672 673 674 675 676
	return i915_drm_thaw_early(dev);
}

int i915_resume(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	int ret;

677 678
	/*
	 * Platforms with opregion should have sane BIOS, older ones (gen3 and
679 680
	 * earlier) need to restore the GTT mappings since the BIOS might clear
	 * all our scratch PTEs.
681
	 */
682
	ret = __i915_drm_thaw(dev, !dev_priv->opregion.header);
683 684 685 686 687
	if (ret)
		return ret;

	drm_kms_helper_poll_enable(dev);
	return 0;
J
Jesse Barnes 已提交
688 689
}

690 691 692 693 694 695 696 697
static int i915_resume_legacy(struct drm_device *dev)
{
	i915_resume_early(dev);
	i915_resume(dev);

	return 0;
}

698
/**
699
 * i915_reset - reset chip after a hang
700 701 702 703 704 705 706 707 708 709 710 711 712
 * @dev: drm device to reset
 *
 * Reset the chip.  Useful if a hang is detected. Returns zero on successful
 * reset or otherwise an error code.
 *
 * Procedure is fairly simple:
 *   - reset the chip using the reset reg
 *   - re-init context state
 *   - re-init hardware status page
 *   - re-init ring buffer
 *   - re-init interrupt state
 *   - re-init display
 */
713
int i915_reset(struct drm_device *dev)
714
{
715
	struct drm_i915_private *dev_priv = dev->dev_private;
716
	bool simulated;
717
	int ret;
718

719
	if (!i915.reset)
C
Chris Wilson 已提交
720 721
		return 0;

722
	mutex_lock(&dev->struct_mutex);
723

724
	i915_gem_reset(dev);
725

726 727
	simulated = dev_priv->gpu_error.stop_rings != 0;

728 729 730 731 732 733 734
	ret = intel_gpu_reset(dev);

	/* Also reset the gpu hangman. */
	if (simulated) {
		DRM_INFO("Simulated gpu hang, resetting stop_rings\n");
		dev_priv->gpu_error.stop_rings = 0;
		if (ret == -ENODEV) {
735 736
			DRM_INFO("Reset not implemented, but ignoring "
				 "error for simulated gpu hangs\n");
737 738
			ret = 0;
		}
739
	}
740

741
	if (ret) {
742
		DRM_ERROR("Failed to reset chip: %i\n", ret);
743
		mutex_unlock(&dev->struct_mutex);
744
		return ret;
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
	}

	/* Ok, now get things going again... */

	/*
	 * Everything depends on having the GTT running, so we need to start
	 * there.  Fortunately we don't need to do this unless we reset the
	 * chip at a PCI level.
	 *
	 * Next we need to restore the context, but we don't use those
	 * yet either...
	 *
	 * Ring buffer needs to be re-initialized in the KMS case, or if X
	 * was running at the time of the reset (i.e. we weren't VT
	 * switched away).
	 */
	if (drm_core_check_feature(dev, DRIVER_MODESET) ||
762 763
			!dev_priv->ums.mm_suspended) {
		dev_priv->ums.mm_suspended = 0;
764

765
		ret = i915_gem_init_hw(dev);
766
		mutex_unlock(&dev->struct_mutex);
767 768 769 770
		if (ret) {
			DRM_ERROR("Failed hw init on reset %d\n", ret);
			return ret;
		}
771

772 773 774 775 776
		/*
		 * FIXME: This is horribly race against concurrent pageflip and
		 * vblank wait ioctls since they can observe dev->irqs_disabled
		 * being false when they shouldn't be able to.
		 */
777
		drm_irq_uninstall(dev);
778
		drm_irq_install(dev, dev->pdev->irq);
J
Jeff McGee 已提交
779 780 781 782 783

		/* rps/rc6 re-init is necessary to restore state lost after the
		 * reset and the re-install of drm irq. Skip for ironlake per
		 * previous concerns that it doesn't respond well to some forms
		 * of re-init after reset. */
784
		if (INTEL_INFO(dev)->gen > 5)
785
			intel_reset_gt_powersave(dev);
J
Jeff McGee 已提交
786

787
		intel_hpd_init(dev);
788 789
	} else {
		mutex_unlock(&dev->struct_mutex);
790 791 792 793 794
	}

	return 0;
}

795
static int i915_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
796
{
797 798 799
	struct intel_device_info *intel_info =
		(struct intel_device_info *) ent->driver_data;

800
	if (IS_PRELIMINARY_HW(intel_info) && !i915.preliminary_hw_support) {
801 802 803 804 805
		DRM_INFO("This hardware requires preliminary hardware support.\n"
			 "See CONFIG_DRM_I915_PRELIMINARY_HW_SUPPORT, and/or modparam preliminary_hw_support\n");
		return -ENODEV;
	}

806 807 808 809 810 811 812 813
	/* Only bind to function 0 of the device. Early generations
	 * used function 1 as a placeholder for multi-head. This causes
	 * us confusion instead, especially on the systems where both
	 * functions have the same PCI-ID!
	 */
	if (PCI_FUNC(pdev->devfn))
		return -ENODEV;

D
Daniel Vetter 已提交
814
	driver.driver_features &= ~(DRIVER_USE_AGP);
815

816
	return drm_get_pci_dev(pdev, ent, &driver);
817 818 819 820 821 822 823 824 825 826
}

static void
i915_pci_remove(struct pci_dev *pdev)
{
	struct drm_device *dev = pci_get_drvdata(pdev);

	drm_put_dev(dev);
}

827
static int i915_pm_suspend(struct device *dev)
828
{
829 830
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
831

832 833 834 835
	if (!drm_dev || !drm_dev->dev_private) {
		dev_err(dev, "DRM not initialized, aborting suspend.\n");
		return -ENODEV;
	}
836

837 838 839
	if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;

840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858
	return i915_drm_freeze(drm_dev);
}

static int i915_pm_suspend_late(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	/*
	 * We have a suspedn ordering issue with the snd-hda driver also
	 * requiring our device to be power up. Due to the lack of a
	 * parent/child relationship we currently solve this with an late
	 * suspend hook.
	 *
	 * FIXME: This should be solved with a special hdmi sink device or
	 * similar so that power domains can be employed.
	 */
	if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;
859

860 861
	pci_disable_device(pdev);
	pci_set_power_state(pdev, PCI_D3hot);
862

863
	return 0;
864 865
}

866 867 868 869 870 871 872 873
static int i915_pm_resume_early(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_resume_early(drm_dev);
}

874
static int i915_pm_resume(struct device *dev)
875
{
876 877 878 879
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_resume(drm_dev);
880 881
}

882
static int i915_pm_freeze(struct device *dev)
883
{
884 885 886 887 888 889 890 891 892
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	if (!drm_dev || !drm_dev->dev_private) {
		dev_err(dev, "DRM not initialized, aborting suspend.\n");
		return -ENODEV;
	}

	return i915_drm_freeze(drm_dev);
893 894
}

895 896 897 898 899 900 901 902
static int i915_pm_thaw_early(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_drm_thaw_early(drm_dev);
}

903
static int i915_pm_thaw(struct device *dev)
904
{
905 906 907 908
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_drm_thaw(drm_dev);
909 910
}

911
static int i915_pm_poweroff(struct device *dev)
912
{
913 914 915
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

916
	return i915_drm_freeze(drm_dev);
917 918
}

919 920
static void hsw_runtime_suspend(struct drm_i915_private *dev_priv)
{
P
Paulo Zanoni 已提交
921
	hsw_enable_pc8(dev_priv);
922 923
}

924 925 926 927 928 929 930
static void snb_runtime_resume(struct drm_i915_private *dev_priv)
{
	struct drm_device *dev = dev_priv->dev;

	intel_init_pch_refclk(dev);
}

931 932
static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
{
P
Paulo Zanoni 已提交
933
	hsw_disable_pc8(dev_priv);
934 935 936
}

static int intel_runtime_suspend(struct device *device)
937 938 939 940 941
{
	struct pci_dev *pdev = to_pci_dev(device);
	struct drm_device *dev = pci_get_drvdata(pdev);
	struct drm_i915_private *dev_priv = dev->dev_private;

942
	if (WARN_ON_ONCE(!(dev_priv->rps.enabled && intel_enable_rc6(dev))))
943 944
		return -ENODEV;

945
	WARN_ON(!HAS_RUNTIME_PM(dev));
946
	assert_force_wake_inactive(dev_priv);
947 948 949

	DRM_DEBUG_KMS("Suspending device\n");

950 951 952 953 954 955
	/*
	 * rps.work can't be rearmed here, since we get here only after making
	 * sure the GPU is idle and the RPS freq is set to the minimum. See
	 * intel_mark_idle().
	 */
	cancel_work_sync(&dev_priv->rps.work);
956 957
	intel_runtime_pm_disable_interrupts(dev);

958
	if (IS_GEN6(dev))
959
		;
960
	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
961
		hsw_runtime_suspend(dev_priv);
962 963
	else
		WARN_ON(1);
964

965 966
	i915_gem_release_all_mmaps(dev_priv);

967
	del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);
968
	dev_priv->pm.suspended = true;
969 970 971 972 973 974 975 976 977

	/*
	 * current versions of firmware which depend on this opregion
	 * notification have repurposed the D1 definition to mean
	 * "runtime suspended" vs. what you would normally expect (D3)
	 * to distinguish it from notifications that might be sent
	 * via the suspend path.
	 */
	intel_opregion_notify_adapter(dev, PCI_D1);
978

979
	DRM_DEBUG_KMS("Device suspended\n");
980 981 982
	return 0;
}

983
static int intel_runtime_resume(struct device *device)
984 985 986 987 988 989 990 991 992
{
	struct pci_dev *pdev = to_pci_dev(device);
	struct drm_device *dev = pci_get_drvdata(pdev);
	struct drm_i915_private *dev_priv = dev->dev_private;

	WARN_ON(!HAS_RUNTIME_PM(dev));

	DRM_DEBUG_KMS("Resuming device\n");

993
	intel_opregion_notify_adapter(dev, PCI_D0);
994 995
	dev_priv->pm.suspended = false;

996 997
	if (IS_GEN6(dev))
		snb_runtime_resume(dev_priv);
998
	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
999
		hsw_runtime_resume(dev_priv);
1000 1001
	else
		WARN_ON(1);
1002

1003 1004 1005
	i915_gem_init_swizzling(dev);
	gen6_update_ring_freq(dev);

1006
	intel_runtime_pm_restore_interrupts(dev);
1007
	intel_reset_gt_powersave(dev);
1008

1009
	DRM_DEBUG_KMS("Device resumed\n");
1010 1011 1012
	return 0;
}

1013
static const struct dev_pm_ops i915_pm_ops = {
1014
	.suspend = i915_pm_suspend,
1015 1016
	.suspend_late = i915_pm_suspend_late,
	.resume_early = i915_pm_resume_early,
1017 1018
	.resume = i915_pm_resume,
	.freeze = i915_pm_freeze,
1019
	.thaw_early = i915_pm_thaw_early,
1020 1021
	.thaw = i915_pm_thaw,
	.poweroff = i915_pm_poweroff,
1022
	.restore_early = i915_pm_resume_early,
1023
	.restore = i915_pm_resume,
1024 1025
	.runtime_suspend = intel_runtime_suspend,
	.runtime_resume = intel_runtime_resume,
1026 1027
};

1028
static const struct vm_operations_struct i915_gem_vm_ops = {
1029
	.fault = i915_gem_fault,
1030 1031
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
1032 1033
};

1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
static const struct file_operations i915_driver_fops = {
	.owner = THIS_MODULE,
	.open = drm_open,
	.release = drm_release,
	.unlocked_ioctl = drm_ioctl,
	.mmap = drm_gem_mmap,
	.poll = drm_poll,
	.read = drm_read,
#ifdef CONFIG_COMPAT
	.compat_ioctl = i915_compat_ioctl,
#endif
	.llseek = noop_llseek,
};

L
Linus Torvalds 已提交
1048
static struct drm_driver driver = {
1049 1050
	/* Don't use MTRRs here; the Xserver or userspace app should
	 * deal with them for Intel hardware.
D
Dave Airlie 已提交
1051
	 */
1052
	.driver_features =
D
Daniel Vetter 已提交
1053
	    DRIVER_USE_AGP |
1054 1055
	    DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM | DRIVER_PRIME |
	    DRIVER_RENDER,
1056
	.load = i915_driver_load,
J
Jesse Barnes 已提交
1057
	.unload = i915_driver_unload,
1058
	.open = i915_driver_open,
1059 1060
	.lastclose = i915_driver_lastclose,
	.preclose = i915_driver_preclose,
1061
	.postclose = i915_driver_postclose,
1062 1063 1064

	/* Used in place of i915_pm_ops for non-DRIVER_MODESET */
	.suspend = i915_suspend,
1065
	.resume = i915_resume_legacy,
1066

1067
	.device_is_agp = i915_driver_device_is_agp,
1068 1069
	.master_create = i915_master_create,
	.master_destroy = i915_master_destroy,
1070
#if defined(CONFIG_DEBUG_FS)
1071 1072
	.debugfs_init = i915_debugfs_init,
	.debugfs_cleanup = i915_debugfs_cleanup,
1073
#endif
1074
	.gem_free_object = i915_gem_free_object,
1075
	.gem_vm_ops = &i915_gem_vm_ops,
1076 1077 1078 1079 1080 1081

	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
	.gem_prime_export = i915_gem_prime_export,
	.gem_prime_import = i915_gem_prime_import,

1082 1083
	.dumb_create = i915_gem_dumb_create,
	.dumb_map_offset = i915_gem_mmap_gtt,
1084
	.dumb_destroy = drm_gem_dumb_destroy,
L
Linus Torvalds 已提交
1085
	.ioctls = i915_ioctls,
1086
	.fops = &i915_driver_fops,
1087 1088 1089 1090 1091 1092
	.name = DRIVER_NAME,
	.desc = DRIVER_DESC,
	.date = DRIVER_DATE,
	.major = DRIVER_MAJOR,
	.minor = DRIVER_MINOR,
	.patchlevel = DRIVER_PATCHLEVEL,
L
Linus Torvalds 已提交
1093 1094
};

1095 1096 1097 1098 1099 1100 1101 1102
static struct pci_driver i915_pci_driver = {
	.name = DRIVER_NAME,
	.id_table = pciidlist,
	.probe = i915_pci_probe,
	.remove = i915_pci_remove,
	.driver.pm = &i915_pm_ops,
};

L
Linus Torvalds 已提交
1103 1104 1105
static int __init i915_init(void)
{
	driver.num_ioctls = i915_max_ioctl;
J
Jesse Barnes 已提交
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116

	/*
	 * If CONFIG_DRM_I915_KMS is set, default to KMS unless
	 * explicitly disabled with the module pararmeter.
	 *
	 * Otherwise, just follow the parameter (defaulting to off).
	 *
	 * Allow optional vga_text_mode_force boot option to override
	 * the default behavior.
	 */
#if defined(CONFIG_DRM_I915_KMS)
1117
	if (i915.modeset != 0)
J
Jesse Barnes 已提交
1118 1119
		driver.driver_features |= DRIVER_MODESET;
#endif
1120
	if (i915.modeset == 1)
J
Jesse Barnes 已提交
1121 1122 1123
		driver.driver_features |= DRIVER_MODESET;

#ifdef CONFIG_VGA_CONSOLE
1124
	if (vgacon_text_force() && i915.modeset == -1)
J
Jesse Barnes 已提交
1125 1126 1127
		driver.driver_features &= ~DRIVER_MODESET;
#endif

D
Daniel Vetter 已提交
1128
	if (!(driver.driver_features & DRIVER_MODESET)) {
1129
		driver.get_vblank_timestamp = NULL;
D
Daniel Vetter 已提交
1130 1131 1132 1133 1134
#ifndef CONFIG_DRM_I915_UMS
		/* Silently fail loading to not upset userspace. */
		return 0;
#endif
	}
1135

1136
	return drm_pci_init(&driver, &i915_pci_driver);
L
Linus Torvalds 已提交
1137 1138 1139 1140
}

static void __exit i915_exit(void)
{
1141 1142 1143 1144 1145
#ifndef CONFIG_DRM_I915_UMS
	if (!(driver.driver_features & DRIVER_MODESET))
		return; /* Never loaded a driver. */
#endif

1146
	drm_pci_exit(&driver, &i915_pci_driver);
L
Linus Torvalds 已提交
1147 1148 1149 1150 1151
}

module_init(i915_init);
module_exit(i915_exit);

D
Dave Airlie 已提交
1152 1153
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
L
Linus Torvalds 已提交
1154
MODULE_LICENSE("GPL and additional rights");