i915_drv.c 21 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
/* i915_drv.c -- i830,i845,i855,i865,i915 driver -*- linux-c -*-
 */
Dave Airlie's avatar
Dave Airlie committed
3
/*
4
 *
Linus Torvalds's avatar
Linus Torvalds committed
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.
 *
Dave Airlie's avatar
Dave Airlie committed
28
 */
Linus Torvalds's avatar
Linus Torvalds committed
29

30
#include <linux/device.h>
Linus Torvalds's avatar
Linus Torvalds committed
31
32
33
34
#include "drmP.h"
#include "drm.h"
#include "i915_drm.h"
#include "i915_drv.h"
35
#include "intel_drv.h"
Linus Torvalds's avatar
Linus Torvalds committed
36

37
#include <linux/console.h>
38
#include "drm_crtc_helper.h"
39

40
static int i915_modeset = -1;
41
42
43
44
module_param_named(modeset, i915_modeset, int, 0400);

unsigned int i915_fbpercrtc = 0;
module_param_named(fbpercrtc, i915_fbpercrtc, int, 0400);
Linus Torvalds's avatar
Linus Torvalds committed
45

46
unsigned int i915_powersave = 1;
47
module_param_named(powersave, i915_powersave, int, 0600);
48

49
50
51
unsigned int i915_semaphores = 0;
module_param_named(semaphores, i915_semaphores, int, 0600);

52
53
54
unsigned int i915_enable_rc6 = 0;
module_param_named(i915_enable_rc6, i915_enable_rc6, int, 0600);

55
56
57
unsigned int i915_lvds_downclock = 0;
module_param_named(lvds_downclock, i915_lvds_downclock, int, 0400);

58
59
60
unsigned int i915_panel_use_ssc = 1;
module_param_named(lvds_use_ssc, i915_panel_use_ssc, int, 0600);

Chris Wilson's avatar
Chris Wilson committed
61
62
63
bool i915_try_reset = true;
module_param_named(reset, i915_try_reset, bool, 0600);

64
static struct drm_driver driver;
65
extern int intel_agp_enabled;
66

67
#define INTEL_VGA_DEVICE(id, info) {		\
68
	.class = PCI_CLASS_DISPLAY_VGA << 8,	\
69
	.class_mask = 0xff0000,			\
70
71
72
73
	.vendor = 0x8086,			\
	.device = id,				\
	.subvendor = PCI_ANY_ID,		\
	.subdevice = PCI_ANY_ID,		\
74
75
	.driver_data = (unsigned long) info }

76
static const struct intel_device_info intel_i830_info = {
77
	.gen = 2, .is_mobile = 1, .cursor_needs_physical = 1,
78
	.has_overlay = 1, .overlay_needs_physical = 1,
79
80
};

81
static const struct intel_device_info intel_845g_info = {
82
	.gen = 2,
83
	.has_overlay = 1, .overlay_needs_physical = 1,
84
85
};

86
static const struct intel_device_info intel_i85x_info = {
87
	.gen = 2, .is_i85x = 1, .is_mobile = 1,
88
	.cursor_needs_physical = 1,
89
	.has_overlay = 1, .overlay_needs_physical = 1,
90
91
};

92
static const struct intel_device_info intel_i865g_info = {
93
	.gen = 2,
94
	.has_overlay = 1, .overlay_needs_physical = 1,
95
96
};

97
static const struct intel_device_info intel_i915g_info = {
98
	.gen = 3, .is_i915g = 1, .cursor_needs_physical = 1,
99
	.has_overlay = 1, .overlay_needs_physical = 1,
100
};
101
static const struct intel_device_info intel_i915gm_info = {
102
	.gen = 3, .is_mobile = 1,
103
	.cursor_needs_physical = 1,
104
	.has_overlay = 1, .overlay_needs_physical = 1,
105
	.supports_tv = 1,
106
};
107
static const struct intel_device_info intel_i945g_info = {
108
	.gen = 3, .has_hotplug = 1, .cursor_needs_physical = 1,
109
	.has_overlay = 1, .overlay_needs_physical = 1,
110
};
111
static const struct intel_device_info intel_i945gm_info = {
112
	.gen = 3, .is_i945gm = 1, .is_mobile = 1,
113
	.has_hotplug = 1, .cursor_needs_physical = 1,
114
	.has_overlay = 1, .overlay_needs_physical = 1,
115
	.supports_tv = 1,
116
117
};

118
static const struct intel_device_info intel_i965g_info = {
119
	.gen = 4, .is_broadwater = 1,
120
	.has_hotplug = 1,
121
	.has_overlay = 1,
122
123
};

124
static const struct intel_device_info intel_i965gm_info = {
125
	.gen = 4, .is_crestline = 1,
126
	.is_mobile = 1, .has_fbc = 1, .has_hotplug = 1,
127
	.has_overlay = 1,
128
	.supports_tv = 1,
129
130
};

131
static const struct intel_device_info intel_g33_info = {
132
	.gen = 3, .is_g33 = 1,
133
	.need_gfx_hws = 1, .has_hotplug = 1,
134
	.has_overlay = 1,
135
136
};

137
static const struct intel_device_info intel_g45_info = {
138
	.gen = 4, .is_g4x = 1, .need_gfx_hws = 1,
139
	.has_pipe_cxsr = 1, .has_hotplug = 1,
140
	.has_bsd_ring = 1,
141
142
};

143
static const struct intel_device_info intel_gm45_info = {
144
	.gen = 4, .is_g4x = 1,
145
	.is_mobile = 1, .need_gfx_hws = 1, .has_fbc = 1,
146
	.has_pipe_cxsr = 1, .has_hotplug = 1,
147
	.supports_tv = 1,
148
	.has_bsd_ring = 1,
149
150
};

151
static const struct intel_device_info intel_pineview_info = {
152
	.gen = 3, .is_g33 = 1, .is_pineview = 1, .is_mobile = 1,
153
	.need_gfx_hws = 1, .has_hotplug = 1,
154
	.has_overlay = 1,
155
156
};

157
static const struct intel_device_info intel_ironlake_d_info = {
158
	.gen = 5,
159
	.need_gfx_hws = 1, .has_pipe_cxsr = 1, .has_hotplug = 1,
160
	.has_bsd_ring = 1,
161
162
};

163
static const struct intel_device_info intel_ironlake_m_info = {
164
	.gen = 5, .is_mobile = 1,
165
	.need_gfx_hws = 1, .has_hotplug = 1,
166
	.has_fbc = 0, /* disabled due to buggy hardware */
167
	.has_bsd_ring = 1,
168
169
};

170
static const struct intel_device_info intel_sandybridge_d_info = {
171
	.gen = 6,
172
	.need_gfx_hws = 1, .has_hotplug = 1,
173
	.has_bsd_ring = 1,
174
	.has_blt_ring = 1,
175
176
};

177
static const struct intel_device_info intel_sandybridge_m_info = {
178
	.gen = 6, .is_mobile = 1,
179
	.need_gfx_hws = 1, .has_hotplug = 1,
180
	.has_fbc = 1,
181
	.has_bsd_ring = 1,
182
	.has_blt_ring = 1,
183
184
};

185
186
187
188
static const struct pci_device_id pciidlist[] = {		/* aka */
	INTEL_VGA_DEVICE(0x3577, &intel_i830_info),		/* I830_M */
	INTEL_VGA_DEVICE(0x2562, &intel_845g_info),		/* 845_G */
	INTEL_VGA_DEVICE(0x3582, &intel_i85x_info),		/* I855_GM */
189
	INTEL_VGA_DEVICE(0x358e, &intel_i85x_info),
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
	INTEL_VGA_DEVICE(0x2572, &intel_i865g_info),		/* I865_G */
	INTEL_VGA_DEVICE(0x2582, &intel_i915g_info),		/* I915_G */
	INTEL_VGA_DEVICE(0x258a, &intel_i915g_info),		/* E7221_G */
	INTEL_VGA_DEVICE(0x2592, &intel_i915gm_info),		/* I915_GM */
	INTEL_VGA_DEVICE(0x2772, &intel_i945g_info),		/* I945_G */
	INTEL_VGA_DEVICE(0x27a2, &intel_i945gm_info),		/* I945_GM */
	INTEL_VGA_DEVICE(0x27ae, &intel_i945gm_info),		/* I945_GME */
	INTEL_VGA_DEVICE(0x2972, &intel_i965g_info),		/* I946_GZ */
	INTEL_VGA_DEVICE(0x2982, &intel_i965g_info),		/* G35_G */
	INTEL_VGA_DEVICE(0x2992, &intel_i965g_info),		/* I965_Q */
	INTEL_VGA_DEVICE(0x29a2, &intel_i965g_info),		/* I965_G */
	INTEL_VGA_DEVICE(0x29b2, &intel_g33_info),		/* Q35_G */
	INTEL_VGA_DEVICE(0x29c2, &intel_g33_info),		/* G33_G */
	INTEL_VGA_DEVICE(0x29d2, &intel_g33_info),		/* Q33_G */
	INTEL_VGA_DEVICE(0x2a02, &intel_i965gm_info),		/* I965_GM */
	INTEL_VGA_DEVICE(0x2a12, &intel_i965gm_info),		/* I965_GME */
	INTEL_VGA_DEVICE(0x2a42, &intel_gm45_info),		/* GM45_G */
	INTEL_VGA_DEVICE(0x2e02, &intel_g45_info),		/* IGD_E_G */
	INTEL_VGA_DEVICE(0x2e12, &intel_g45_info),		/* Q45_G */
	INTEL_VGA_DEVICE(0x2e22, &intel_g45_info),		/* G45_G */
	INTEL_VGA_DEVICE(0x2e32, &intel_g45_info),		/* G41_G */
	INTEL_VGA_DEVICE(0x2e42, &intel_g45_info),		/* B43_G */
212
	INTEL_VGA_DEVICE(0x2e92, &intel_g45_info),		/* B43_G.1 */
213
214
215
216
	INTEL_VGA_DEVICE(0xa001, &intel_pineview_info),
	INTEL_VGA_DEVICE(0xa011, &intel_pineview_info),
	INTEL_VGA_DEVICE(0x0042, &intel_ironlake_d_info),
	INTEL_VGA_DEVICE(0x0046, &intel_ironlake_m_info),
217
	INTEL_VGA_DEVICE(0x0102, &intel_sandybridge_d_info),
218
219
	INTEL_VGA_DEVICE(0x0112, &intel_sandybridge_d_info),
	INTEL_VGA_DEVICE(0x0122, &intel_sandybridge_d_info),
220
	INTEL_VGA_DEVICE(0x0106, &intel_sandybridge_m_info),
221
	INTEL_VGA_DEVICE(0x0116, &intel_sandybridge_m_info),
222
	INTEL_VGA_DEVICE(0x0126, &intel_sandybridge_m_info),
223
	INTEL_VGA_DEVICE(0x010A, &intel_sandybridge_d_info),
224
	{0, 0, 0}
Linus Torvalds's avatar
Linus Torvalds committed
225
226
};

227
228
229
230
#if defined(CONFIG_DRM_I915_KMS)
MODULE_DEVICE_TABLE(pci, pciidlist);
#endif

231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
#define INTEL_PCH_DEVICE_ID_MASK	0xff00
#define INTEL_PCH_CPT_DEVICE_ID_TYPE	0x1c00

void intel_detect_pch (struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct pci_dev *pch;

	/*
	 * 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.
	 */
	pch = pci_get_class(PCI_CLASS_BRIDGE_ISA << 8, NULL);
	if (pch) {
		if (pch->vendor == PCI_VENDOR_ID_INTEL) {
			int id;
			id = pch->device & INTEL_PCH_DEVICE_ID_MASK;

			if (id == INTEL_PCH_CPT_DEVICE_ID_TYPE) {
				dev_priv->pch_type = PCH_CPT;
				DRM_DEBUG_KMS("Found CougarPoint PCH\n");
			}
		}
		pci_dev_put(pch);
	}
}

260
void __gen6_gt_force_wake_get(struct drm_i915_private *dev_priv)
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
{
	int count;

	count = 0;
	while (count++ < 50 && (I915_READ_NOTRACE(FORCEWAKE_ACK) & 1))
		udelay(10);

	I915_WRITE_NOTRACE(FORCEWAKE, 1);
	POSTING_READ(FORCEWAKE);

	count = 0;
	while (count++ < 50 && (I915_READ_NOTRACE(FORCEWAKE_ACK) & 1) == 0)
		udelay(10);
}

276
void __gen6_gt_force_wake_put(struct drm_i915_private *dev_priv)
277
278
279
280
281
{
	I915_WRITE_NOTRACE(FORCEWAKE, 0);
	POSTING_READ(FORCEWAKE);
}

282
283
284
285
286
287
288
289
290
291
void __gen6_gt_wait_for_fifo(struct drm_i915_private *dev_priv)
{
	int loop = 500;
	u32 fifo = I915_READ_NOTRACE(GT_FIFO_FREE_ENTRIES);
	while (fifo < 20 && loop--) {
		udelay(10);
		fifo = I915_READ_NOTRACE(GT_FIFO_FREE_ENTRIES);
	}
}

292
static int i915_drm_freeze(struct drm_device *dev)
293
{
294
295
	struct drm_i915_private *dev_priv = dev->dev_private;

296
297
	drm_kms_helper_poll_disable(dev);

298
299
	pci_save_state(dev->pdev);

300
	/* If KMS is active, we do the leavevt stuff here */
301
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
302
303
		int error = i915_gem_idle(dev);
		if (error) {
304
			dev_err(&dev->pdev->dev,
305
306
307
				"GEM idle failed, resume might fail\n");
			return error;
		}
308
		drm_irq_uninstall(dev);
309
310
	}

311
312
	i915_save_state(dev);

313
	intel_opregion_fini(dev);
314

315
316
	/* Modeset on resume, not lid events */
	dev_priv->modeset_on_lid = 0;
317
318

	return 0;
319
320
}

321
int i915_suspend(struct drm_device *dev, pm_message_t state)
322
323
324
325
326
327
328
329
330
331
332
333
{
	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;

334
335
336

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

338
339
340
341
	error = i915_drm_freeze(dev);
	if (error)
		return error;

342
343
344
345
346
	if (state.event == PM_EVENT_SUSPEND) {
		/* Shut down the device */
		pci_disable_device(dev->pdev);
		pci_set_power_state(dev->pdev, PCI_D3hot);
	}
347
348
349
350

	return 0;
}

351
static int i915_drm_thaw(struct drm_device *dev)
352
{
353
	struct drm_i915_private *dev_priv = dev->dev_private;
354
	int error = 0;
355

356
357
358
359
360
361
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		mutex_lock(&dev->struct_mutex);
		i915_gem_restore_gtt_mappings(dev);
		mutex_unlock(&dev->struct_mutex);
	}

362
	i915_restore_state(dev);
363
	intel_opregion_setup(dev);
364

365
366
367
368
369
	/* KMS EnterVT equivalent */
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		mutex_lock(&dev->struct_mutex);
		dev_priv->mm.suspended = 0;

370
		error = i915_gem_init_ringbuffer(dev);
371
		mutex_unlock(&dev->struct_mutex);
372

373
		drm_mode_config_reset(dev);
374
		drm_irq_install(dev);
375

376
377
		/* Resume the modeset for every activated CRTC */
		drm_helper_resume_force_mode(dev);
378

379
		if (IS_IRONLAKE_M(dev))
Jesse Barnes's avatar
Jesse Barnes committed
380
381
			ironlake_enable_rc6(dev);
	}
382

383
384
	intel_opregion_init(dev);

385
	dev_priv->modeset_on_lid = 0;
386

387
388
389
	return error;
}

390
int i915_resume(struct drm_device *dev)
391
{
392
393
	int ret;

394
395
396
	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;

397
398
399
400
401
	if (pci_enable_device(dev->pdev))
		return -EIO;

	pci_set_master(dev->pdev);

402
403
404
405
406
407
	ret = i915_drm_thaw(dev);
	if (ret)
		return ret;

	drm_kms_helper_poll_enable(dev);
	return 0;
408
409
}

410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
static int i8xx_do_reset(struct drm_device *dev, u8 flags)
{
	struct drm_i915_private *dev_priv = dev->dev_private;

	if (IS_I85X(dev))
		return -ENODEV;

	I915_WRITE(D_STATE, I915_READ(D_STATE) | DSTATE_GFX_RESET_I830);
	POSTING_READ(D_STATE);

	if (IS_I830(dev) || IS_845G(dev)) {
		I915_WRITE(DEBUG_RESET_I830,
			   DEBUG_RESET_DISPLAY |
			   DEBUG_RESET_RENDER |
			   DEBUG_RESET_FULL);
		POSTING_READ(DEBUG_RESET_I830);
		msleep(1);

		I915_WRITE(DEBUG_RESET_I830, 0);
		POSTING_READ(DEBUG_RESET_I830);
	}

	msleep(1);

	I915_WRITE(D_STATE, I915_READ(D_STATE) & ~DSTATE_GFX_RESET_I830);
	POSTING_READ(D_STATE);

	return 0;
}

440
441
442
static int i965_reset_complete(struct drm_device *dev)
{
	u8 gdrst;
443
	pci_read_config_byte(dev->pdev, I965_GDRST, &gdrst);
444
445
446
	return gdrst & 0x1;
}

447
448
449
450
static int i965_do_reset(struct drm_device *dev, u8 flags)
{
	u8 gdrst;

451
452
453
454
455
	/*
	 * Set the domains we want to reset (GRDOM/bits 2 and 3) as
	 * well as the reset bit (GR/bit 0).  Setting the GR bit
	 * triggers the reset; when done, the hardware will clear it.
	 */
456
457
458
459
460
461
462
463
464
465
466
467
	pci_read_config_byte(dev->pdev, I965_GDRST, &gdrst);
	pci_write_config_byte(dev->pdev, I965_GDRST, gdrst | flags | 0x1);

	return wait_for(i965_reset_complete(dev), 500);
}

static int ironlake_do_reset(struct drm_device *dev, u8 flags)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	u32 gdrst = I915_READ(MCHBAR_MIRROR_BASE + ILK_GDSR);
	I915_WRITE(MCHBAR_MIRROR_BASE + ILK_GDSR, gdrst | flags | 0x1);
	return wait_for(I915_READ(MCHBAR_MIRROR_BASE + ILK_GDSR) & 0x1, 500);
468
469
}

470
471
472
473
474
475
476
477
static int gen6_do_reset(struct drm_device *dev, u8 flags)
{
	struct drm_i915_private *dev_priv = dev->dev_private;

	I915_WRITE(GEN6_GDRST, GEN6_GRDOM_FULL);
	return wait_for((I915_READ(GEN6_GDRST) & GEN6_GRDOM_FULL) == 0, 500);
}

478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
/**
 * i965_reset - reset chip after a hang
 * @dev: drm device to reset
 * @flags: reset domains
 *
 * 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
 */
494
int i915_reset(struct drm_device *dev, u8 flags)
495
496
497
498
499
500
501
{
	drm_i915_private_t *dev_priv = dev->dev_private;
	/*
	 * We really should only reset the display subsystem if we actually
	 * need to
	 */
	bool need_display = true;
502
	int ret;
503

Chris Wilson's avatar
Chris Wilson committed
504
505
506
	if (!i915_try_reset)
		return 0;

507
508
	if (!mutex_trylock(&dev->struct_mutex))
		return -EBUSY;
509

510
	i915_gem_reset(dev);
511

512
	ret = -ENODEV;
513
514
515
	if (get_seconds() - dev_priv->last_gpu_reset < 5) {
		DRM_ERROR("GPU hanging too fast, declaring wedged!\n");
	} else switch (INTEL_INFO(dev)->gen) {
516
517
518
	case 6:
		ret = gen6_do_reset(dev, flags);
		break;
519
	case 5:
520
		ret = ironlake_do_reset(dev, flags);
521
522
		break;
	case 4:
523
		ret = i965_do_reset(dev, flags);
524
		break;
525
526
527
	case 2:
		ret = i8xx_do_reset(dev, flags);
		break;
528
	}
529
	dev_priv->last_gpu_reset = get_seconds();
530
	if (ret) {
531
		DRM_ERROR("Failed to reset chip.\n");
532
		mutex_unlock(&dev->struct_mutex);
533
		return ret;
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
	}

	/* 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) ||
551
			!dev_priv->mm.suspended) {
552
		dev_priv->mm.suspended = 0;
553

554
		dev_priv->ring[RCS].init(&dev_priv->ring[RCS]);
555
		if (HAS_BSD(dev))
556
		    dev_priv->ring[VCS].init(&dev_priv->ring[VCS]);
557
		if (HAS_BLT(dev))
558
		    dev_priv->ring[BCS].init(&dev_priv->ring[BCS]);
559

560
561
		mutex_unlock(&dev->struct_mutex);
		drm_irq_uninstall(dev);
562
		drm_mode_config_reset(dev);
563
564
565
566
		drm_irq_install(dev);
		mutex_lock(&dev->struct_mutex);
	}

567
568
	mutex_unlock(&dev->struct_mutex);

569
	/*
570
571
572
	 * Perform a full modeset as on later generations, e.g. Ironlake, we may
	 * need to retrain the display link and cannot just restore the register
	 * values.
573
	 */
574
575
576
577
578
	if (need_display) {
		mutex_lock(&dev->mode_config.mutex);
		drm_helper_resume_force_mode(dev);
		mutex_unlock(&dev->mode_config.mutex);
	}
579
580
581
582
583

	return 0;
}


584
585
586
static int __devinit
i915_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
587
588
589
590
591
592
593
594
	/* 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;

595
	return drm_get_pci_dev(pdev, ent, &driver);
596
597
598
599
600
601
602
603
604
605
}

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

	drm_put_dev(dev);
}

606
static int i915_pm_suspend(struct device *dev)
607
{
608
609
610
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	int error;
611

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

617
618
619
	if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;

620
621
622
	error = i915_drm_freeze(drm_dev);
	if (error)
		return error;
623

624
625
	pci_disable_device(pdev);
	pci_set_power_state(pdev, PCI_D3hot);
626

627
	return 0;
628
629
}

630
static int i915_pm_resume(struct device *dev)
631
{
632
633
634
635
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_resume(drm_dev);
636
637
}

638
static int i915_pm_freeze(struct device *dev)
639
{
640
641
642
643
644
645
646
647
648
	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);
649
650
}

651
static int i915_pm_thaw(struct device *dev)
652
{
653
654
655
656
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_drm_thaw(drm_dev);
657
658
}

659
static int i915_pm_poweroff(struct device *dev)
660
{
661
662
663
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

664
	return i915_drm_freeze(drm_dev);
665
666
}

667
static const struct dev_pm_ops i915_pm_ops = {
668
669
670
671
672
     .suspend = i915_pm_suspend,
     .resume = i915_pm_resume,
     .freeze = i915_pm_freeze,
     .thaw = i915_pm_thaw,
     .poweroff = i915_pm_poweroff,
673
     .restore = i915_pm_resume,
674
675
};

676
677
static struct vm_operations_struct i915_gem_vm_ops = {
	.fault = i915_gem_fault,
678
679
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
680
681
};

Linus Torvalds's avatar
Linus Torvalds committed
682
static struct drm_driver driver = {
Dave Airlie's avatar
Dave Airlie committed
683
684
685
	/* don't use mtrr's here, the Xserver or user space app should
	 * deal with them for intel hardware.
	 */
686
687
688
	.driver_features =
	    DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | /* DRIVER_USE_MTRR |*/
	    DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM,
689
	.load = i915_driver_load,
690
	.unload = i915_driver_unload,
691
	.open = i915_driver_open,
692
693
	.lastclose = i915_driver_lastclose,
	.preclose = i915_driver_preclose,
694
	.postclose = i915_driver_postclose,
695
696
697
698
699

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

700
	.device_is_agp = i915_driver_device_is_agp,
701
702
	.enable_vblank = i915_enable_vblank,
	.disable_vblank = i915_disable_vblank,
703
704
	.get_vblank_timestamp = i915_get_vblank_timestamp,
	.get_scanout_position = i915_get_crtc_scanoutpos,
Linus Torvalds's avatar
Linus Torvalds committed
705
706
707
708
709
	.irq_preinstall = i915_driver_irq_preinstall,
	.irq_postinstall = i915_driver_irq_postinstall,
	.irq_uninstall = i915_driver_irq_uninstall,
	.irq_handler = i915_driver_irq_handler,
	.reclaim_buffers = drm_core_reclaim_buffers,
710
711
	.master_create = i915_master_create,
	.master_destroy = i915_master_destroy,
712
#if defined(CONFIG_DEBUG_FS)
713
714
	.debugfs_init = i915_debugfs_init,
	.debugfs_cleanup = i915_debugfs_cleanup,
715
#endif
716
717
	.gem_init_object = i915_gem_init_object,
	.gem_free_object = i915_gem_free_object,
718
	.gem_vm_ops = &i915_gem_vm_ops,
Linus Torvalds's avatar
Linus Torvalds committed
719
720
	.ioctls = i915_ioctls,
	.fops = {
Dave Airlie's avatar
Dave Airlie committed
721
722
723
		 .owner = THIS_MODULE,
		 .open = drm_open,
		 .release = drm_release,
724
		 .unlocked_ioctl = drm_ioctl,
725
		 .mmap = drm_gem_mmap,
Dave Airlie's avatar
Dave Airlie committed
726
727
		 .poll = drm_poll,
		 .fasync = drm_fasync,
728
		 .read = drm_read,
729
#ifdef CONFIG_COMPAT
Dave Airlie's avatar
Dave Airlie committed
730
		 .compat_ioctl = i915_compat_ioctl,
731
#endif
Arnd Bergmann's avatar
Arnd Bergmann committed
732
		 .llseek = noop_llseek,
733
734
	},

Linus Torvalds's avatar
Linus Torvalds committed
735
	.pci_driver = {
736
737
		 .name = DRIVER_NAME,
		 .id_table = pciidlist,
738
739
		 .probe = i915_pci_probe,
		 .remove = i915_pci_remove,
740
		 .driver.pm = &i915_pm_ops,
741
	},
742

743
744
745
746
747
748
	.name = DRIVER_NAME,
	.desc = DRIVER_DESC,
	.date = DRIVER_DATE,
	.major = DRIVER_MAJOR,
	.minor = DRIVER_MINOR,
	.patchlevel = DRIVER_PATCHLEVEL,
Linus Torvalds's avatar
Linus Torvalds committed
749
750
751
752
};

static int __init i915_init(void)
{
753
754
755
756
757
	if (!intel_agp_enabled) {
		DRM_ERROR("drm/i915 can't work without intel_agp module!\n");
		return -ENODEV;
	}

Linus Torvalds's avatar
Linus Torvalds committed
758
	driver.num_ioctls = i915_max_ioctl;
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780

	/*
	 * 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)
	if (i915_modeset != 0)
		driver.driver_features |= DRIVER_MODESET;
#endif
	if (i915_modeset == 1)
		driver.driver_features |= DRIVER_MODESET;

#ifdef CONFIG_VGA_CONSOLE
	if (vgacon_text_force() && i915_modeset == -1)
		driver.driver_features &= ~DRIVER_MODESET;
#endif

781
782
783
	if (!(driver.driver_features & DRIVER_MODESET))
		driver.get_vblank_timestamp = NULL;

Linus Torvalds's avatar
Linus Torvalds committed
784
785
786
787
788
789
790
791
792
793
794
	return drm_init(&driver);
}

static void __exit i915_exit(void)
{
	drm_exit(&driver);
}

module_init(i915_init);
module_exit(i915_exit);

Dave Airlie's avatar
Dave Airlie committed
795
796
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds's avatar
Linus Torvalds committed
797
MODULE_LICENSE("GPL and additional rights");