i915_drv.c 40.1 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>
31 32
#include <drm/drmP.h>
#include <drm/i915_drm.h>
Linus Torvalds's avatar
Linus Torvalds committed
33
#include "i915_drv.h"
34
#include "i915_trace.h"
35
#include "intel_drv.h"
Linus Torvalds's avatar
Linus Torvalds committed
36

37
#include <linux/console.h>
38
#include <linux/module.h>
39
#include <drm/drm_crtc_helper.h>
40

41
static int i915_modeset __read_mostly = -1;
42
module_param_named(modeset, i915_modeset, int, 0400);
43 44 45
MODULE_PARM_DESC(modeset,
		"Use kernel modesetting [KMS] (0=DRM_I915_KMS from .config, "
		"1=on, -1=force vga console preference [default])");
46

47
unsigned int i915_fbpercrtc __always_unused = 0;
48
module_param_named(fbpercrtc, i915_fbpercrtc, int, 0400);
Linus Torvalds's avatar
Linus Torvalds committed
49

50
int i915_panel_ignore_lid __read_mostly = 1;
51
module_param_named(panel_ignore_lid, i915_panel_ignore_lid, int, 0600);
52
MODULE_PARM_DESC(panel_ignore_lid,
53 54
		"Override lid status (0=autodetect, 1=autodetect disabled [default], "
		"-1=force lid closed, -2=force lid open)");
55

56
unsigned int i915_powersave __read_mostly = 1;
57
module_param_named(powersave, i915_powersave, int, 0600);
58 59
MODULE_PARM_DESC(powersave,
		"Enable powersavings, fbc, downclocking, etc. (default: true)");
60

61
int i915_semaphores __read_mostly = -1;
62
module_param_named(semaphores, i915_semaphores, int, 0600);
63
MODULE_PARM_DESC(semaphores,
64
		"Use semaphores for inter-ring sync (default: -1 (use per-chip defaults))");
65

66
int i915_enable_rc6 __read_mostly = -1;
67
module_param_named(i915_enable_rc6, i915_enable_rc6, int, 0400);
68
MODULE_PARM_DESC(i915_enable_rc6,
69 70 71 72 73
		"Enable power-saving render C-state 6. "
		"Different stages can be selected via bitmask values "
		"(0 = disable; 1 = enable rc6; 2 = enable deep rc6; 4 = enable deepest rc6). "
		"For example, 3 would enable rc6 and deep rc6, and 7 would enable everything. "
		"default: -1 (use per-chip default)");
74

75
int i915_enable_fbc __read_mostly = -1;
76
module_param_named(i915_enable_fbc, i915_enable_fbc, int, 0600);
77 78
MODULE_PARM_DESC(i915_enable_fbc,
		"Enable frame buffer compression for power savings "
79
		"(default: -1 (use per-chip default))");
80

81
unsigned int i915_lvds_downclock __read_mostly = 0;
82
module_param_named(lvds_downclock, i915_lvds_downclock, int, 0400);
83 84 85
MODULE_PARM_DESC(lvds_downclock,
		"Use panel (LVDS/eDP) downclocking for power savings "
		"(default: false)");
86

87 88 89 90 91 92
int i915_lvds_channel_mode __read_mostly;
module_param_named(lvds_channel_mode, i915_lvds_channel_mode, int, 0600);
MODULE_PARM_DESC(lvds_channel_mode,
		 "Specify LVDS channel mode "
		 "(0=probe BIOS [default], 1=single-channel, 2=dual-channel)");

93
int i915_panel_use_ssc __read_mostly = -1;
94
module_param_named(lvds_use_ssc, i915_panel_use_ssc, int, 0600);
95 96
MODULE_PARM_DESC(lvds_use_ssc,
		"Use Spread Spectrum Clock with panels [LVDS/eDP] "
97
		"(default: auto from VBT)");
98

99
int i915_vbt_sdvo_panel_type __read_mostly = -1;
100
module_param_named(vbt_sdvo_panel_type, i915_vbt_sdvo_panel_type, int, 0600);
101
MODULE_PARM_DESC(vbt_sdvo_panel_type,
102 103
		"Override/Ignore selection of SDVO panel mode in the VBT "
		"(-2=ignore, -1=auto [default], index in VBT BIOS table)");
104

105
static bool i915_try_reset __read_mostly = true;
106
module_param_named(reset, i915_try_reset, bool, 0600);
107
MODULE_PARM_DESC(reset, "Attempt GPU resets (default: true)");
108

109
bool i915_enable_hangcheck __read_mostly = true;
110
module_param_named(enable_hangcheck, i915_enable_hangcheck, bool, 0644);
111 112 113 114
MODULE_PARM_DESC(enable_hangcheck,
		"Periodically check GPU activity for detecting hangs. "
		"WARNING: Disabling this can cause system wide hangs. "
		"(default: true)");
115

116 117
int i915_enable_ppgtt __read_mostly = -1;
module_param_named(i915_enable_ppgtt, i915_enable_ppgtt, int, 0600);
Daniel Vetter's avatar
Daniel Vetter committed
118 119 120
MODULE_PARM_DESC(i915_enable_ppgtt,
		"Enable PPGTT (default: true)");

121 122 123
unsigned int i915_preliminary_hw_support __read_mostly = 0;
module_param_named(preliminary_hw_support, i915_preliminary_hw_support, int, 0600);
MODULE_PARM_DESC(preliminary_hw_support,
124
		"Enable preliminary hardware support. (default: false)");
125

126 127 128 129 130
int i915_disable_power_well __read_mostly = 0;
module_param_named(disable_power_well, i915_disable_power_well, int, 0600);
MODULE_PARM_DESC(disable_power_well,
		 "Disable the power well when possible (default: false)");

131 132 133 134
int i915_enable_ips __read_mostly = 1;
module_param_named(enable_ips, i915_enable_ips, int, 0600);
MODULE_PARM_DESC(enable_ips, "Enable IPS (default: true)");

135
static struct drm_driver driver;
136
extern int intel_agp_enabled;
137

138
#define INTEL_VGA_DEVICE(id, info) {		\
139
	.class = PCI_BASE_CLASS_DISPLAY << 16,	\
140
	.class_mask = 0xff0000,			\
141 142 143 144
	.vendor = 0x8086,			\
	.device = id,				\
	.subvendor = PCI_ANY_ID,		\
	.subdevice = PCI_ANY_ID,		\
145 146
	.driver_data = (unsigned long) info }

147 148 149 150 151 152 153 154 155 156
#define INTEL_QUANTA_VGA_DEVICE(info) {		\
	.class = PCI_BASE_CLASS_DISPLAY << 16,	\
	.class_mask = 0xff0000,			\
	.vendor = 0x8086,			\
	.device = 0x16a,			\
	.subvendor = 0x152d,			\
	.subdevice = 0x8990,			\
	.driver_data = (unsigned long) info }


157
static const struct intel_device_info intel_i830_info = {
158
	.gen = 2, .is_mobile = 1, .cursor_needs_physical = 1, .num_pipes = 2,
159
	.has_overlay = 1, .overlay_needs_physical = 1,
160 161
};

162
static const struct intel_device_info intel_845g_info = {
163
	.gen = 2, .num_pipes = 1,
164
	.has_overlay = 1, .overlay_needs_physical = 1,
165 166
};

167
static const struct intel_device_info intel_i85x_info = {
168
	.gen = 2, .is_i85x = 1, .is_mobile = 1, .num_pipes = 2,
169
	.cursor_needs_physical = 1,
170
	.has_overlay = 1, .overlay_needs_physical = 1,
171 172
};

173
static const struct intel_device_info intel_i865g_info = {
174
	.gen = 2, .num_pipes = 1,
175
	.has_overlay = 1, .overlay_needs_physical = 1,
176 177
};

178
static const struct intel_device_info intel_i915g_info = {
179
	.gen = 3, .is_i915g = 1, .cursor_needs_physical = 1, .num_pipes = 2,
180
	.has_overlay = 1, .overlay_needs_physical = 1,
181
};
182
static const struct intel_device_info intel_i915gm_info = {
183
	.gen = 3, .is_mobile = 1, .num_pipes = 2,
184
	.cursor_needs_physical = 1,
185
	.has_overlay = 1, .overlay_needs_physical = 1,
186
	.supports_tv = 1,
187
};
188
static const struct intel_device_info intel_i945g_info = {
189
	.gen = 3, .has_hotplug = 1, .cursor_needs_physical = 1, .num_pipes = 2,
190
	.has_overlay = 1, .overlay_needs_physical = 1,
191
};
192
static const struct intel_device_info intel_i945gm_info = {
193
	.gen = 3, .is_i945gm = 1, .is_mobile = 1, .num_pipes = 2,
194
	.has_hotplug = 1, .cursor_needs_physical = 1,
195
	.has_overlay = 1, .overlay_needs_physical = 1,
196
	.supports_tv = 1,
197 198
};

199
static const struct intel_device_info intel_i965g_info = {
200
	.gen = 4, .is_broadwater = 1, .num_pipes = 2,
201
	.has_hotplug = 1,
202
	.has_overlay = 1,
203 204
};

205
static const struct intel_device_info intel_i965gm_info = {
206
	.gen = 4, .is_crestline = 1, .num_pipes = 2,
207
	.is_mobile = 1, .has_fbc = 1, .has_hotplug = 1,
208
	.has_overlay = 1,
209
	.supports_tv = 1,
210 211
};

212
static const struct intel_device_info intel_g33_info = {
213
	.gen = 3, .is_g33 = 1, .num_pipes = 2,
214
	.need_gfx_hws = 1, .has_hotplug = 1,
215
	.has_overlay = 1,
216 217
};

218
static const struct intel_device_info intel_g45_info = {
219
	.gen = 4, .is_g4x = 1, .need_gfx_hws = 1, .num_pipes = 2,
220
	.has_pipe_cxsr = 1, .has_hotplug = 1,
221
	.has_bsd_ring = 1,
222 223
};

224
static const struct intel_device_info intel_gm45_info = {
225
	.gen = 4, .is_g4x = 1, .num_pipes = 2,
226
	.is_mobile = 1, .need_gfx_hws = 1, .has_fbc = 1,
227
	.has_pipe_cxsr = 1, .has_hotplug = 1,
228
	.supports_tv = 1,
229
	.has_bsd_ring = 1,
230 231
};

232
static const struct intel_device_info intel_pineview_info = {
233
	.gen = 3, .is_g33 = 1, .is_pineview = 1, .is_mobile = 1, .num_pipes = 2,
234
	.need_gfx_hws = 1, .has_hotplug = 1,
235
	.has_overlay = 1,
236 237
};

238
static const struct intel_device_info intel_ironlake_d_info = {
239
	.gen = 5, .num_pipes = 2,
240
	.need_gfx_hws = 1, .has_hotplug = 1,
241
	.has_bsd_ring = 1,
242 243
};

244
static const struct intel_device_info intel_ironlake_m_info = {
245
	.gen = 5, .is_mobile = 1, .num_pipes = 2,
246
	.need_gfx_hws = 1, .has_hotplug = 1,
247
	.has_fbc = 1,
248
	.has_bsd_ring = 1,
249 250
};

251
static const struct intel_device_info intel_sandybridge_d_info = {
252
	.gen = 6, .num_pipes = 2,
253
	.need_gfx_hws = 1, .has_hotplug = 1,
254
	.has_bsd_ring = 1,
255
	.has_blt_ring = 1,
256
	.has_llc = 1,
257
	.has_force_wake = 1,
258 259
};

260
static const struct intel_device_info intel_sandybridge_m_info = {
261
	.gen = 6, .is_mobile = 1, .num_pipes = 2,
262
	.need_gfx_hws = 1, .has_hotplug = 1,
263
	.has_fbc = 1,
264
	.has_bsd_ring = 1,
265
	.has_blt_ring = 1,
266
	.has_llc = 1,
267
	.has_force_wake = 1,
268 269
};

270 271 272 273 274 275 276 277
#define GEN7_FEATURES  \
	.gen = 7, .num_pipes = 3, \
	.need_gfx_hws = 1, .has_hotplug = 1, \
	.has_bsd_ring = 1, \
	.has_blt_ring = 1, \
	.has_llc = 1, \
	.has_force_wake = 1

278
static const struct intel_device_info intel_ivybridge_d_info = {
279 280
	GEN7_FEATURES,
	.is_ivybridge = 1,
281 282 283
};

static const struct intel_device_info intel_ivybridge_m_info = {
284 285 286
	GEN7_FEATURES,
	.is_ivybridge = 1,
	.is_mobile = 1,
287
	.has_fbc = 1,
288 289
};

290 291 292 293 294 295
static const struct intel_device_info intel_ivybridge_q_info = {
	GEN7_FEATURES,
	.is_ivybridge = 1,
	.num_pipes = 0, /* legal, last one wins */
};

296
static const struct intel_device_info intel_valleyview_m_info = {
297 298 299
	GEN7_FEATURES,
	.is_mobile = 1,
	.num_pipes = 2,
300
	.is_valleyview = 1,
301
	.display_mmio_offset = VLV_DISPLAY_BASE,
302
	.has_llc = 0, /* legal, last one wins */
303 304 305
};

static const struct intel_device_info intel_valleyview_d_info = {
306 307
	GEN7_FEATURES,
	.num_pipes = 2,
308
	.is_valleyview = 1,
309
	.display_mmio_offset = VLV_DISPLAY_BASE,
310
	.has_llc = 0, /* legal, last one wins */
311 312
};

313
static const struct intel_device_info intel_haswell_d_info = {
314 315
	GEN7_FEATURES,
	.is_haswell = 1,
316
	.has_ddi = 1,
317
	.has_fpga_dbg = 1,
Xiang, Haihao's avatar
Xiang, Haihao committed
318
	.has_vebox_ring = 1,
319 320 321
};

static const struct intel_device_info intel_haswell_m_info = {
322 323 324
	GEN7_FEATURES,
	.is_haswell = 1,
	.is_mobile = 1,
325
	.has_ddi = 1,
326
	.has_fpga_dbg = 1,
327
	.has_fbc = 1,
Xiang, Haihao's avatar
Xiang, Haihao committed
328
	.has_vebox_ring = 1,
329 330
};

331 332 333 334
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 */
335
	INTEL_VGA_DEVICE(0x358e, &intel_i85x_info),
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
	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 */
358
	INTEL_VGA_DEVICE(0x2e92, &intel_g45_info),		/* B43_G.1 */
359 360 361 362
	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),
363
	INTEL_VGA_DEVICE(0x0102, &intel_sandybridge_d_info),
364 365
	INTEL_VGA_DEVICE(0x0112, &intel_sandybridge_d_info),
	INTEL_VGA_DEVICE(0x0122, &intel_sandybridge_d_info),
366
	INTEL_VGA_DEVICE(0x0106, &intel_sandybridge_m_info),
367
	INTEL_VGA_DEVICE(0x0116, &intel_sandybridge_m_info),
368
	INTEL_VGA_DEVICE(0x0126, &intel_sandybridge_m_info),
369
	INTEL_VGA_DEVICE(0x010A, &intel_sandybridge_d_info),
370 371 372 373 374
	INTEL_VGA_DEVICE(0x0156, &intel_ivybridge_m_info), /* GT1 mobile */
	INTEL_VGA_DEVICE(0x0166, &intel_ivybridge_m_info), /* GT2 mobile */
	INTEL_VGA_DEVICE(0x0152, &intel_ivybridge_d_info), /* GT1 desktop */
	INTEL_VGA_DEVICE(0x0162, &intel_ivybridge_d_info), /* GT2 desktop */
	INTEL_VGA_DEVICE(0x015a, &intel_ivybridge_d_info), /* GT1 server */
375
	INTEL_QUANTA_VGA_DEVICE(&intel_ivybridge_q_info), /* Quanta transcode */
376
	INTEL_VGA_DEVICE(0x016a, &intel_ivybridge_d_info), /* GT2 server */
377 378
	INTEL_VGA_DEVICE(0x0402, &intel_haswell_d_info), /* GT1 desktop */
	INTEL_VGA_DEVICE(0x0412, &intel_haswell_d_info), /* GT2 desktop */
379
	INTEL_VGA_DEVICE(0x0422, &intel_haswell_d_info), /* GT3 desktop */
380 381
	INTEL_VGA_DEVICE(0x040a, &intel_haswell_d_info), /* GT1 server */
	INTEL_VGA_DEVICE(0x041a, &intel_haswell_d_info), /* GT2 server */
382
	INTEL_VGA_DEVICE(0x042a, &intel_haswell_d_info), /* GT3 server */
383 384
	INTEL_VGA_DEVICE(0x0406, &intel_haswell_m_info), /* GT1 mobile */
	INTEL_VGA_DEVICE(0x0416, &intel_haswell_m_info), /* GT2 mobile */
385
	INTEL_VGA_DEVICE(0x0426, &intel_haswell_m_info), /* GT2 mobile */
386 387 388 389 390 391
	INTEL_VGA_DEVICE(0x040B, &intel_haswell_d_info), /* GT1 reserved */
	INTEL_VGA_DEVICE(0x041B, &intel_haswell_d_info), /* GT2 reserved */
	INTEL_VGA_DEVICE(0x042B, &intel_haswell_d_info), /* GT3 reserved */
	INTEL_VGA_DEVICE(0x040E, &intel_haswell_d_info), /* GT1 reserved */
	INTEL_VGA_DEVICE(0x041E, &intel_haswell_d_info), /* GT2 reserved */
	INTEL_VGA_DEVICE(0x042E, &intel_haswell_d_info), /* GT3 reserved */
392 393
	INTEL_VGA_DEVICE(0x0C02, &intel_haswell_d_info), /* SDV GT1 desktop */
	INTEL_VGA_DEVICE(0x0C12, &intel_haswell_d_info), /* SDV GT2 desktop */
394
	INTEL_VGA_DEVICE(0x0C22, &intel_haswell_d_info), /* SDV GT3 desktop */
395 396
	INTEL_VGA_DEVICE(0x0C0A, &intel_haswell_d_info), /* SDV GT1 server */
	INTEL_VGA_DEVICE(0x0C1A, &intel_haswell_d_info), /* SDV GT2 server */
397
	INTEL_VGA_DEVICE(0x0C2A, &intel_haswell_d_info), /* SDV GT3 server */
398 399
	INTEL_VGA_DEVICE(0x0C06, &intel_haswell_m_info), /* SDV GT1 mobile */
	INTEL_VGA_DEVICE(0x0C16, &intel_haswell_m_info), /* SDV GT2 mobile */
400 401 402 403 404 405 406
	INTEL_VGA_DEVICE(0x0C26, &intel_haswell_m_info), /* SDV GT3 mobile */
	INTEL_VGA_DEVICE(0x0C0B, &intel_haswell_d_info), /* SDV GT1 reserved */
	INTEL_VGA_DEVICE(0x0C1B, &intel_haswell_d_info), /* SDV GT2 reserved */
	INTEL_VGA_DEVICE(0x0C2B, &intel_haswell_d_info), /* SDV GT3 reserved */
	INTEL_VGA_DEVICE(0x0C0E, &intel_haswell_d_info), /* SDV GT1 reserved */
	INTEL_VGA_DEVICE(0x0C1E, &intel_haswell_d_info), /* SDV GT2 reserved */
	INTEL_VGA_DEVICE(0x0C2E, &intel_haswell_d_info), /* SDV GT3 reserved */
407 408
	INTEL_VGA_DEVICE(0x0A02, &intel_haswell_d_info), /* ULT GT1 desktop */
	INTEL_VGA_DEVICE(0x0A12, &intel_haswell_d_info), /* ULT GT2 desktop */
409
	INTEL_VGA_DEVICE(0x0A22, &intel_haswell_d_info), /* ULT GT3 desktop */
410 411
	INTEL_VGA_DEVICE(0x0A0A, &intel_haswell_d_info), /* ULT GT1 server */
	INTEL_VGA_DEVICE(0x0A1A, &intel_haswell_d_info), /* ULT GT2 server */
412
	INTEL_VGA_DEVICE(0x0A2A, &intel_haswell_d_info), /* ULT GT3 server */
413 414
	INTEL_VGA_DEVICE(0x0A06, &intel_haswell_m_info), /* ULT GT1 mobile */
	INTEL_VGA_DEVICE(0x0A16, &intel_haswell_m_info), /* ULT GT2 mobile */
415 416 417 418 419 420 421
	INTEL_VGA_DEVICE(0x0A26, &intel_haswell_m_info), /* ULT GT3 mobile */
	INTEL_VGA_DEVICE(0x0A0B, &intel_haswell_d_info), /* ULT GT1 reserved */
	INTEL_VGA_DEVICE(0x0A1B, &intel_haswell_d_info), /* ULT GT2 reserved */
	INTEL_VGA_DEVICE(0x0A2B, &intel_haswell_d_info), /* ULT GT3 reserved */
	INTEL_VGA_DEVICE(0x0A0E, &intel_haswell_m_info), /* ULT GT1 reserved */
	INTEL_VGA_DEVICE(0x0A1E, &intel_haswell_m_info), /* ULT GT2 reserved */
	INTEL_VGA_DEVICE(0x0A2E, &intel_haswell_m_info), /* ULT GT3 reserved */
422 423
	INTEL_VGA_DEVICE(0x0D02, &intel_haswell_d_info), /* CRW GT1 desktop */
	INTEL_VGA_DEVICE(0x0D12, &intel_haswell_d_info), /* CRW GT2 desktop */
424
	INTEL_VGA_DEVICE(0x0D22, &intel_haswell_d_info), /* CRW GT3 desktop */
425 426
	INTEL_VGA_DEVICE(0x0D0A, &intel_haswell_d_info), /* CRW GT1 server */
	INTEL_VGA_DEVICE(0x0D1A, &intel_haswell_d_info), /* CRW GT2 server */
427
	INTEL_VGA_DEVICE(0x0D2A, &intel_haswell_d_info), /* CRW GT3 server */
428 429
	INTEL_VGA_DEVICE(0x0D06, &intel_haswell_m_info), /* CRW GT1 mobile */
	INTEL_VGA_DEVICE(0x0D16, &intel_haswell_m_info), /* CRW GT2 mobile */
430 431 432 433 434 435 436
	INTEL_VGA_DEVICE(0x0D26, &intel_haswell_m_info), /* CRW GT3 mobile */
	INTEL_VGA_DEVICE(0x0D0B, &intel_haswell_d_info), /* CRW GT1 reserved */
	INTEL_VGA_DEVICE(0x0D1B, &intel_haswell_d_info), /* CRW GT2 reserved */
	INTEL_VGA_DEVICE(0x0D2B, &intel_haswell_d_info), /* CRW GT3 reserved */
	INTEL_VGA_DEVICE(0x0D0E, &intel_haswell_d_info), /* CRW GT1 reserved */
	INTEL_VGA_DEVICE(0x0D1E, &intel_haswell_d_info), /* CRW GT2 reserved */
	INTEL_VGA_DEVICE(0x0D2E, &intel_haswell_d_info), /* CRW GT3 reserved */
437
	INTEL_VGA_DEVICE(0x0f30, &intel_valleyview_m_info),
Jesse Barnes's avatar
Jesse Barnes committed
438 439 440
	INTEL_VGA_DEVICE(0x0f31, &intel_valleyview_m_info),
	INTEL_VGA_DEVICE(0x0f32, &intel_valleyview_m_info),
	INTEL_VGA_DEVICE(0x0f33, &intel_valleyview_m_info),
441 442
	INTEL_VGA_DEVICE(0x0157, &intel_valleyview_m_info),
	INTEL_VGA_DEVICE(0x0155, &intel_valleyview_d_info),
443
	{0, 0, 0}
Linus Torvalds's avatar
Linus Torvalds committed
444 445
};

446 447 448 449
#if defined(CONFIG_DRM_I915_KMS)
MODULE_DEVICE_TABLE(pci, pciidlist);
#endif

450
void intel_detect_pch(struct drm_device *dev)
451 452 453 454
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct pci_dev *pch;

Ben Widawsky's avatar
Ben Widawsky committed
455 456 457 458 459 460 461 462 463
	/* 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;
		dev_priv->num_pch_pll = 0;
		return;
	}

464 465 466 467 468 469 470 471 472
	/*
	 * 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) {
473
			unsigned short id;
474
			id = pch->device & INTEL_PCH_DEVICE_ID_MASK;
475
			dev_priv->pch_id = id;
476

477 478
			if (id == INTEL_PCH_IBX_DEVICE_ID_TYPE) {
				dev_priv->pch_type = PCH_IBX;
479
				dev_priv->num_pch_pll = 2;
480
				DRM_DEBUG_KMS("Found Ibex Peak PCH\n");
481
				WARN_ON(!IS_GEN5(dev));
482
			} else if (id == INTEL_PCH_CPT_DEVICE_ID_TYPE) {
483
				dev_priv->pch_type = PCH_CPT;
484
				dev_priv->num_pch_pll = 2;
485
				DRM_DEBUG_KMS("Found CougarPoint PCH\n");
486
				WARN_ON(!(IS_GEN6(dev) || IS_IVYBRIDGE(dev)));
487 488 489
			} else if (id == INTEL_PCH_PPT_DEVICE_ID_TYPE) {
				/* PantherPoint is CPT compatible */
				dev_priv->pch_type = PCH_CPT;
490
				dev_priv->num_pch_pll = 2;
491
				DRM_DEBUG_KMS("Found PatherPoint PCH\n");
492
				WARN_ON(!(IS_GEN6(dev) || IS_IVYBRIDGE(dev)));
493 494
			} else if (id == INTEL_PCH_LPT_DEVICE_ID_TYPE) {
				dev_priv->pch_type = PCH_LPT;
495
				dev_priv->num_pch_pll = 0;
496
				DRM_DEBUG_KMS("Found LynxPoint PCH\n");
497
				WARN_ON(!IS_HASWELL(dev));
498
				WARN_ON(IS_ULT(dev));
499 500 501 502 503
			} else if (id == INTEL_PCH_LPT_LP_DEVICE_ID_TYPE) {
				dev_priv->pch_type = PCH_LPT;
				dev_priv->num_pch_pll = 0;
				DRM_DEBUG_KMS("Found LynxPoint LP PCH\n");
				WARN_ON(!IS_HASWELL(dev));
504
				WARN_ON(!IS_ULT(dev));
505
			}
506
			BUG_ON(dev_priv->num_pch_pll > I915_NUM_PLLS);
507 508 509 510 511
		}
		pci_dev_put(pch);
	}
}

512 513 514 515 516 517 518 519
bool i915_semaphore_is_enabled(struct drm_device *dev)
{
	if (INTEL_INFO(dev)->gen < 6)
		return 0;

	if (i915_semaphores >= 0)
		return i915_semaphores;

520
#ifdef CONFIG_INTEL_IOMMU
521
	/* Enable semaphores on SNB when IO remapping is off */
522 523 524
	if (INTEL_INFO(dev)->gen == 6 && intel_iommu_gfx_mapped)
		return false;
#endif
525 526 527 528

	return 1;
}

529
static int i915_drm_freeze(struct drm_device *dev)
530
{
531
	struct drm_i915_private *dev_priv = dev->dev_private;
532
	struct drm_crtc *crtc;
533

534 535 536 537 538
	/* 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);

539 540
	intel_set_power_well(dev, true);

541 542
	drm_kms_helper_poll_disable(dev);

543 544
	pci_save_state(dev->pdev);

545
	/* If KMS is active, we do the leavevt stuff here */
546
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
547 548
		int error = i915_gem_idle(dev);
		if (error) {
549
			dev_err(&dev->pdev->dev,
550 551 552
				"GEM idle failed, resume might fail\n");
			return error;
		}
553

554 555
		cancel_delayed_work_sync(&dev_priv->rps.delayed_resume_work);

556
		drm_irq_uninstall(dev);
557
		dev_priv->enable_hotplug_processing = false;
558 559 560 561 562 563
		/*
		 * Disable CRTCs directly since we want to preserve sw state
		 * for _thaw.
		 */
		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
			dev_priv->display.crtc_disable(crtc);
564 565

		intel_modeset_suspend_hw(dev);
566 567
	}

568 569
	i915_save_state(dev);

570
	intel_opregion_fini(dev);
571

572 573 574 575
	console_lock();
	intel_fbdev_set_suspend(dev, 1);
	console_unlock();

576
	return 0;
577 578
}

579
int i915_suspend(struct drm_device *dev, pm_message_t state)
580 581 582 583 584 585 586 587 588 589 590 591
{
	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;

592 593 594

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

596 597 598 599
	error = i915_drm_freeze(dev);
	if (error)
		return error;

600 601 602 603 604
	if (state.event == PM_EVENT_SUSPEND) {
		/* Shut down the device */
		pci_disable_device(dev->pdev);
		pci_set_power_state(dev->pdev, PCI_D3hot);
	}
605 606 607 608

	return 0;
}

609 610 611 612 613 614 615 616 617 618 619 620
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();
	intel_fbdev_set_suspend(dev, 0);
	console_unlock();
}

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
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);
}

639
static int __i915_drm_thaw(struct drm_device *dev)
640
{
641
	struct drm_i915_private *dev_priv = dev->dev_private;
642
	int error = 0;
643

644
	i915_restore_state(dev);
645
	intel_opregion_setup(dev);
646

647 648
	/* KMS EnterVT equivalent */
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
649
		intel_init_pch_refclk(dev);
650

651 652 653
		mutex_lock(&dev->struct_mutex);
		dev_priv->mm.suspended = 0;

654
		error = i915_gem_init_hw(dev);
655
		mutex_unlock(&dev->struct_mutex);
656

657 658 659
		/* We need working interrupts for modeset enabling ... */
		drm_irq_install(dev);

660
		intel_modeset_init_hw(dev);
661 662 663 664

		drm_modeset_lock_all(dev);
		intel_modeset_setup_hw_state(dev, true);
		drm_modeset_unlock_all(dev);
665 666 667 668 669 670 671

		/*
		 * ... 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.
		 * */
672
		intel_hpd_init(dev);
673
		dev_priv->enable_hotplug_processing = true;
674 675
		/* Config may have changed between suspend and resume */
		intel_resume_hotplug(dev);
Jesse Barnes's avatar
Jesse Barnes committed
676
	}
677

678 679
	intel_opregion_init(dev);

680 681 682 683 684 685 686 687 688 689 690 691
	/*
	 * 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()) {
		intel_fbdev_set_suspend(dev, 0);
		console_unlock();
	} else {
		schedule_work(&dev_priv->console_resume_work);
	}

692 693 694
	mutex_lock(&dev_priv->modeset_restore_lock);
	dev_priv->modeset_restore = MODESET_DONE;
	mutex_unlock(&dev_priv->modeset_restore_lock);
695 696 697
	return error;
}

698 699 700 701 702 703 704 705 706 707 708 709 710 711
static int i915_drm_thaw(struct drm_device *dev)
{
	int error = 0;

	intel_gt_reset(dev);

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

	__i915_drm_thaw(dev);

712 713 714
	return error;
}

715
int i915_resume(struct drm_device *dev)
716
{
717
	struct drm_i915_private *dev_priv = dev->dev_private;
718 719
	int ret;

720 721 722
	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;

723 724 725 726 727
	if (pci_enable_device(dev->pdev))
		return -EIO;

	pci_set_master(dev->pdev);

728 729 730 731 732 733 734 735 736 737 738 739 740 741
	intel_gt_reset(dev);

	/*
	 * Platforms with opregion should have sane BIOS, older ones (gen3 and
	 * earlier) need this since the BIOS might clear all our scratch PTEs.
	 */
	if (drm_core_check_feature(dev, DRIVER_MODESET) &&
	    !dev_priv->opregion.header) {
		mutex_lock(&dev->struct_mutex);
		i915_gem_restore_gtt_mappings(dev);
		mutex_unlock(&dev->struct_mutex);
	}

	ret = __i915_drm_thaw(dev);
742 743 744 745 746
	if (ret)
		return ret;

	drm_kms_helper_poll_enable(dev);
	return 0;
747 748
}

749
static int i8xx_do_reset(struct drm_device *dev)
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
{
	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;
}

779 780 781
static int i965_reset_complete(struct drm_device *dev)
{
	u8 gdrst;
782
	pci_read_config_byte(dev->pdev, I965_GDRST, &gdrst);
Daniel Vetter's avatar
Daniel Vetter committed
783
	return (gdrst & GRDOM_RESET_ENABLE) == 0;
784 785
}

786
static int i965_do_reset(struct drm_device *dev)
787
{
788
	int ret;
789 790
	u8 gdrst;

791 792 793 794 795
	/*
	 * 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.
	 */
796
	pci_read_config_byte(dev->pdev, I965_GDRST, &gdrst);
797
	pci_write_config_byte(dev->pdev, I965_GDRST,
798 799 800 801 802 803 804 805 806 807 808
			      gdrst | GRDOM_RENDER |
			      GRDOM_RESET_ENABLE);
	ret =  wait_for(i965_reset_complete(dev), 500);
	if (ret)
		return ret;

	/* We can't reset render&media without also resetting display ... */
	pci_read_config_byte(dev->pdev, I965_GDRST, &gdrst);
	pci_write_config_byte(dev->pdev, I965_GDRST,
			      gdrst | GRDOM_MEDIA |
			      GRDOM_RESET_ENABLE);
809 810 811 812

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

813
static int ironlake_do_reset(struct drm_device *dev)
814 815
{
	struct drm_i915_private *dev_priv = dev->dev_private;
816 817 818 819
	u32 gdrst;
	int ret;

	gdrst = I915_READ(MCHBAR_MIRROR_BASE + ILK_GDSR);
820
	gdrst &= ~GRDOM_MASK;
821 822 823 824 825 826 827 828
	I915_WRITE(MCHBAR_MIRROR_BASE + ILK_GDSR,
		   gdrst | GRDOM_RENDER | GRDOM_RESET_ENABLE);
	ret = wait_for(I915_READ(MCHBAR_MIRROR_BASE + ILK_GDSR) & 0x1, 500);
	if (ret)
		return ret;

	/* We can't reset render&media without also resetting display ... */
	gdrst = I915_READ(MCHBAR_MIRROR_BASE + ILK_GDSR);
829
	gdrst &= ~GRDOM_MASK;
830
	I915_WRITE(MCHBAR_MIRROR_BASE + ILK_GDSR,
831
		   gdrst | GRDOM_MEDIA | GRDOM_RESET_ENABLE);
832
	return wait_for(I915_READ(MCHBAR_MIRROR_BASE + ILK_GDSR) & 0x1, 500);
833 834
}

835
static int gen6_do_reset(struct drm_device *dev)
836 837
{
	struct drm_i915_private *dev_priv = dev->dev_private;
838 839
	int	ret;
	unsigned long irqflags;
840

841 842 843
	/* Hold gt_lock across reset to prevent any register access
	 * with forcewake not set correctly
	 */
844
	spin_lock_irqsave(&dev_priv->gt_lock, irqflags);
845 846 847 848 849 850 851 852 853 854 855 856 857

	/* Reset the chip */

	/* GEN6_GDRST is not in the gt power well, no need to check
	 * for fifo space for the write or forcewake the chip for
	 * the read
	 */
	I915_WRITE_NOTRACE(GEN6_GDRST, GEN6_GRDOM_FULL);

	/* Spin waiting for the device to ack the reset request */
	ret = wait_for((I915_READ_NOTRACE(GEN6_GDRST) & GEN6_GRDOM_FULL) == 0, 500);

	/* If reset with a user forcewake, try to restore, otherwise turn it off */
858
	if (dev_priv->forcewake_count)
859
		dev_priv->gt.force_wake_get(dev_priv);
860
	else
861
		dev_priv->gt.force_wake_put(dev_priv);
862 863 864 865

	/* Restore fifo count */
	dev_priv->gt_fifo_count = I915_READ_NOTRACE(GT_FIFO_FREE_ENTRIES);

866 867
	spin_unlock_irqrestore(&dev_priv->gt_lock, irqflags);
	return ret;
868 869
}

870
int intel_gpu_reset(struct drm_device *dev)
871 872 873
{
	switch (INTEL_INFO(dev)->gen) {
	case 7:
874 875 876 877 878
	case 6: return gen6_do_reset(dev);
	case 5: return ironlake_do_reset(dev);
	case 4: return i965_do_reset(dev);
	case 2: return i8xx_do_reset(dev);
	default: return -ENODEV;
879 880 881
	}
}

882
/**
883
 * i915_reset - reset chip after a hang
884 885 886 887 888 889 890 891 892 893 894 895 896
 * @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
 */
897
int i915_reset(struct drm_device *dev)
898 899
{
	drm_i915_private_t *dev_priv = dev->dev_private;
900
	bool simulated;
901
	int ret;
902

903 904 905
	if (!i915_try_reset)
		return 0;

906
	mutex_lock(&dev->struct_mutex);
907

908
	i915_gem_reset(dev);
909

910 911 912
	simulated = dev_priv->gpu_error.stop_rings != 0;

	if (!simulated && get_seconds() - dev_priv->gpu_error.last_reset < 5) {
913
		DRM_ERROR("GPU hanging too fast, declaring wedged!\n");
914 915
		ret = -ENODEV;
	} else {
916
		ret = intel_gpu_reset(dev);
917

918 919 920 921 922 923 924 925 926 927 928 929
		/* 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) {
				DRM_ERROR("Reset not implemented, but ignoring "
					  "error for simulated gpu hangs\n");
				ret = 0;
			}
		} else
			dev_priv->gpu_error.last_reset = get_seconds();
	}
930
	if (ret) {
931
		DRM_ERROR("Failed to reset chip.\n");
932
		mutex_unlock(&dev->struct_mutex);
933
		return ret;
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
	}

	/* 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) ||
951
			!dev_priv->mm.suspended) {
952 953 954
		struct intel_ring_buffer *ring;
		int i;

955
		dev_priv->mm.suspended = 0;
956

957 958
		i915_gem_init_swizzling(dev);

959 960
		for_each_ring(ring, dev_priv, i)
			ring->init(ring);
961

962
		i915_gem_context_init(dev);
963 964 965 966 967
		if (dev_priv->mm.aliasing_ppgtt) {
			ret = dev_priv->mm.aliasing_ppgtt->enable(dev);
			if (ret)
				i915_gem_cleanup_aliasing_ppgtt(dev);
		}
Daniel Vetter's avatar
Daniel Vetter committed
968

969 970 971 972 973
		/*
		 * It would make sense to re-init all the other hw state, at
		 * least the rps/rc6/emon init done within modeset_init_hw. For
		 * some unknown reason, this blows up my ilk, so don't.
		 */
974

975
		mutex_unlock(&dev->struct_mutex);
976

977 978
		drm_irq_uninstall(dev);
		drm_irq_install(dev);
979
		intel_hpd_init(dev);
980 981
	} else {
		mutex_unlock(&dev->struct_mutex);
982 983 984 985 986
	}

	return 0;
}

987
static int i915_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
988
{
989 990 991
	struct intel_device_info *intel_info =
		(struct intel_device_info *) ent->driver_data;

992 993 994 995 996 997 998 999
	/* 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;

1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
	/* We've managed to ship a kms-enabled ddx that shipped with an XvMC
	 * implementation for gen3 (and only gen3) that used legacy drm maps
	 * (gasp!) to share buffers between X and the client. Hence we need to
	 * keep around the fake agp stuff for gen3, even when kms is enabled. */
	if (intel_info->gen != 3) {
		driver.driver_features &=
			~(DRIVER_USE_AGP | DRIVER_REQUIRE_AGP);
	} else if (!intel_agp_enabled) {
		DRM_ERROR("drm/i915 can't work without intel_agp module!\n");
		return -ENODEV;
	}

1012
	return drm_get_pci_dev(pdev, ent, &driver);
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
}

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

	drm_put_dev(dev);
}

1023
static int i915_pm_suspend(struct device *dev)
1024
{
1025 1026 1027
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	int error;
1028

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

1034 1035 1036
	if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF)
		return 0;

1037 1038 1039
	error = i915_drm_freeze(drm_dev);
	if (error)
		return error;
1040

1041 1042
	pci_disable_device(pdev);
	pci_set_power_state(pdev, PCI_D3hot);
1043

1044
	return 0;
1045 1046
}

1047
static int i915_pm_resume(struct device *dev)
1048
{
1049 1050 1051 1052
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_resume(drm_dev);
1053 1054
}

1055
static int i915_pm_freeze(struct device *dev)
1056
{
1057 1058 1059 1060 1061 1062 1063 1064 1065
	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);
1066 1067
}

1068
static int i915_pm_thaw(struct device *dev)
1069
{
1070 1071 1072 1073
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

	return i915_drm_thaw(drm_dev);
1074 1075
}

1076
static int i915_pm_poweroff(struct device *dev)
1077
{
1078 1079 1080
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);

1081
	return i915_drm_freeze(drm_dev);
1082 1083
}

1084
static const struct dev_pm_ops i915_pm_ops = {
1085 1086 1087 1088 1089 1090
	.suspend = i915_pm_suspend,
	.resume = i915_pm_resume,
	.freeze = i915_pm_freeze,
	.thaw = i915_pm_thaw,
	.poweroff = i915_pm_poweroff,
	.restore = i915_pm_resume,
1091 1092
};

1093
static const struct vm_operations_struct i915_gem_vm_ops = {
1094
	.fault = i915_gem_fault,
1095 1096
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
1097 1098
};

1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
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,
	.fasync = drm_fasync,
	.read = drm_read,
#ifdef CONFIG_COMPAT
	.compat_ioctl = i915_compat_ioctl,
#endif
	.llseek = noop_llseek,
};

Linus Torvalds's avatar
Linus Torvalds committed
1114
static struct drm_driver driver = {
1115 1116
	/* Don't use MTRRs here; the Xserver or userspace app should
	 * deal with them for Intel hardware.
Dave Airlie's avatar
Dave Airlie committed
1117
	 */
1118 1119
	.driver_features =
	    DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | /* DRIVER_USE_MTRR |*/
1120
	    DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM | DRIVER_PRIME,
1121
	.load = i915_driver_load,
1122
	.unload = i915_driver_unload,
1123
	.open = i915_driver_open,
1124 1125
	.lastclose = i915_driver_lastclose,
	.preclose = i915_driver_preclose,
1126
	.postclose = i915_driver_postclose,
1127 1128 1129 1130 1131

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

1132
	.device_is_agp = i915_driver_device_is_agp,
1133 1134
	.master_create = i915_master_create,
	.master_destroy = i915_master_destroy,
1135
#if defined(CONFIG_DEBUG_FS)
1136 1137
	.debugfs_init = i915_debugfs_init,
	.debugfs_cleanup = i915_debugfs_cleanup,
1138
#endif
1139 1140
	.gem_init_object = i915_gem_init_object,
	.gem_free_object = i915_gem_free_object,
1141
	.gem_vm_ops = &i915_gem_vm_ops,
1142 1143 1144 1145 1146 1147

	.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,

1148 1149 1150
	.dumb_create = i915_gem_dumb_create,
	.dumb_map_offset = i915_gem_mmap_gtt,
	.dumb_destroy = i915_gem_dumb_destroy,
Linus Torvalds's avatar
Linus Torvalds committed
1151
	.ioctls = i915_ioctls,
1152
	.fops = &i915_driver_fops,
1153 1154 1155 1156 1157 1158
	.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
1159 1160
};

1161 1162 1163 1164 1165 1166 1167 1168
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,
};

Linus Torvalds's avatar
Linus Torvalds committed
1169 1170 1171
static int __init i915_init(void)
{
	driver.num_ioctls = i915_max_ioctl;
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193

	/*
	 * 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

1194 1195 1196
	if (!(driver.driver_features & DRIVER_MODESET))
		driver.get_vblank_timestamp = NULL;

1197
	return drm_pci_init(&driver, &i915_pci_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1198 1199 1200 1201
}

static void __exit i915_exit(void)
{
1202
	drm_pci_exit(&driver, &i915_pci_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1203 1204 1205 1206 1207
}

module_init(i915_init);
module_exit(i915_exit);

1208 1209
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds's avatar
Linus Torvalds committed
1210
MODULE_LICENSE("GPL and additional rights");
1211

1212 1213
/* We give fast paths for the really cool registers */
#define NEEDS_FORCE_WAKE(dev_priv, reg) \
1214 1215 1216
	((HAS_FORCE_WAKE((dev_priv)->dev)) && \
	 ((reg) < 0x40000) &&            \
	 ((reg) != FORCEWAKE))
1217 1218 1219
static void
ilk_dummy_write(struct drm_i915_private *dev_priv)
{
1220 1221 1222
	/* WaIssueDummyWriteToWakeupFromRC6:ilk Issue a dummy write to wake up
	 * the chip from rc6 before touching it for real. MI_MODE is masked,
	 * hence harmless to write 0 into. */
1223 1224 1225
	I915_WRITE_NOTRACE(MI_MODE, 0);
}

1226 1227 1228
static void
hsw_unclaimed_reg_clear(struct drm_i915_private *dev_priv, u32 reg)
{
1229
	if (HAS_FPGA_DBG_UNCLAIMED(dev_priv->dev) &&
1230
	    (I915_READ_NOTRACE(FPGA_DBG) & FPGA_DBG_RM_NOCLAIM)) {
1231 1232
		DRM_ERROR("Unknown unclaimed register before writing to %x\n",
			  reg);
1233
		I915_WRITE_NOTRACE(FPGA_DBG, FPGA_DBG_RM_NOCLAIM);
1234 1235 1236 1237 1238 1239
	}
}

static void
hsw_unclaimed_reg_check(struct drm_i915_private *dev_priv, u32 reg)
{
1240
	if (HAS_FPGA_DBG_UNCLAIMED(dev_priv->dev) &&
1241
	    (I915_READ_NOTRACE(FPGA_DBG) & FPGA_DBG_RM_NOCLAIM)) {
1242
		DRM_ERROR("Unclaimed write to %x\n", reg);
1243
		I915_WRITE_NOTRACE(FPGA_DBG, FPGA_DBG_RM_NOCLAIM);
1244 1245 1246
	}
}

1247 1248 1249
#define __i915_read(x, y) \
u##x i915_read##x(struct drm_i915_private *dev_priv, u32 reg) { \
	u##x val = 0; \
1250 1251
	if (IS_GEN5(dev_priv->dev)) \
		ilk_dummy_write(dev_priv); \
1252
	if (NEEDS_FORCE_WAKE((dev_priv), (reg))) { \
1253 1254 1255
		unsigned long irqflags; \
		spin_lock_irqsave(&dev_priv->gt_lock, irqflags); \
		if (dev_priv->forcewake_count == 0) \
1256
			dev_priv->gt.force_wake_get(dev_priv); \
1257
		val = read##y(dev_priv->regs + reg); \
1258
		if (dev_priv->forcewake_count == 0) \
1259
			dev_priv->gt.force_wake_put(dev_priv); \
1260
		spin_unlock_irqrestore(&dev_priv->gt_lock, irqflags); \
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
	} else { \
		val = read##y(dev_priv->regs + reg); \
	} \
	trace_i915_reg_rw(false, reg, val, sizeof(val)); \
	return val; \
}

__i915_read(8, b)
__i915_read(16, w)
__i915_read(32, l)
__i915_read(64, q)
#undef __i915_read

#define __i915_write(x, y) \
void i915_write##x(struct drm_i915_private *dev_priv, u32 reg, u##x val) { \
1276
	u32 __fifo_ret = 0; \
1277 1278
	trace_i915_reg_rw(true, reg, val, sizeof(val)); \
	if (NEEDS_FORCE_WAKE((dev_priv), (reg))) { \
1279
		__fifo_ret = __gen6_gt_wait_for_fifo(dev_priv); \
1280
	} \
1281 1282
	if (IS_GEN5(dev_priv->dev)) \
		ilk_dummy_write(dev_priv); \
1283
	hsw_unclaimed_reg_clear(dev_priv, reg); \
1284
	write##y(val, dev_priv->regs + reg); \
1285 1286 1287
	if (unlikely(__fifo_ret)) { \
		gen6_gt_check_fifodbg(dev_priv); \
	} \
1288
	hsw_unclaimed_reg_check(dev_priv, reg); \
1289 1290 1291 1292 1293 1294
}
__i915_write(8, b)
__i915_write(16, w)
__i915_write(32, l)
__i915_write(64, q)
#undef __i915_write
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340

static const struct register_whitelist {
	uint64_t offset;
	uint32_t size;
	uint32_t gen_bitmask; /* support gens, 0x10 for 4, 0x30 for 4 and 5, etc. */
} whitelist[] = {
	{ RING_TIMESTAMP(RENDER_RING_BASE), 8, 0xF0 },
};

int i915_reg_read_ioctl(struct drm_device *dev,
			void *data, struct drm_file *file)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct drm_i915_reg_read *reg = data;
	struct register_whitelist const *entry = whitelist;
	int i;

	for (i = 0; i < ARRAY_SIZE(whitelist); i++, entry++) {
		if (entry->offset == reg->offset &&
		    (1 << INTEL_INFO(dev)->gen & entry->gen_bitmask))
			break;
	}

	if (i == ARRAY_SIZE(whitelist))
		return -EINVAL;

	switch (entry->size) {
	case 8:
		reg->val = I915_READ64(reg->offset);
		break;
	case 4:
		reg->val = I915_READ(reg->offset);
		break;
	case 2:
		reg->val = I915_READ16(reg->offset);
		break;
	case 1:
		reg->val = I915_READ8(reg->offset);
		break;
	default:
		WARN_ON(1);
		return -EINVAL;
	}

	return 0;
}