i915_dma.c 34.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
/* i915_dma.c -- DMA support for the I915 -*- linux-c -*-
 */
Dave Airlie's avatar
Dave Airlie committed
3
/*
Linus Torvalds's avatar
Linus Torvalds committed
4
5
 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
 * All Rights Reserved.
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 *
 * 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
27
 */
Linus Torvalds's avatar
Linus Torvalds committed
28
29
30

#include "drmP.h"
#include "drm.h"
31
32
#include "drm_crtc_helper.h"
#include "intel_drv.h"
Linus Torvalds's avatar
Linus Torvalds committed
33
34
35
36
37
38
39
40
#include "i915_drm.h"
#include "i915_drv.h"

/* Really want an OS-independent resettable timer.  Would like to have
 * this loop run for (eg) 3 sec, but have the timer reset every time
 * the head pointer changes, so that EBUSY only happens if the ring
 * actually stalls for (eg) 3 seconds.
 */
41
int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
Linus Torvalds's avatar
Linus Torvalds committed
42
43
{
	drm_i915_private_t *dev_priv = dev->dev_private;
44
	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
Linus Torvalds's avatar
Linus Torvalds committed
45
	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
46
47
48
	u32 acthd_reg = IS_I965G(dev) ? ACTHD_I965 : ACTHD;
	u32 last_acthd = I915_READ(acthd_reg);
	u32 acthd;
49
	u32 last_head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
Linus Torvalds's avatar
Linus Torvalds committed
50
51
	int i;

52
	for (i = 0; i < 100000; i++) {
53
		ring->head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
54
		acthd = I915_READ(acthd_reg);
Linus Torvalds's avatar
Linus Torvalds committed
55
56
57
58
59
60
		ring->space = ring->head - (ring->tail + 8);
		if (ring->space < 0)
			ring->space += ring->Size;
		if (ring->space >= n)
			return 0;

61
62
		if (master_priv->sarea_priv)
			master_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
Linus Torvalds's avatar
Linus Torvalds committed
63
64
65

		if (ring->head != last_head)
			i = 0;
66
67
		if (acthd != last_acthd)
			i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
68
69

		last_head = ring->head;
70
71
72
		last_acthd = acthd;
		msleep_interruptible(10);

Linus Torvalds's avatar
Linus Torvalds committed
73
74
	}

Eric Anholt's avatar
Eric Anholt committed
75
	return -EBUSY;
Linus Torvalds's avatar
Linus Torvalds committed
76
77
}

78
79
80
81
/**
 * Sets up the hardware status page for devices that need a physical address
 * in the register.
 */
82
static int i915_init_phys_hws(struct drm_device *dev)
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
{
	drm_i915_private_t *dev_priv = dev->dev_private;
	/* Program Hardware Status Page */
	dev_priv->status_page_dmah =
		drm_pci_alloc(dev, PAGE_SIZE, PAGE_SIZE, 0xffffffff);

	if (!dev_priv->status_page_dmah) {
		DRM_ERROR("Can not allocate hardware status page\n");
		return -ENOMEM;
	}
	dev_priv->hw_status_page = dev_priv->status_page_dmah->vaddr;
	dev_priv->dma_status_page = dev_priv->status_page_dmah->busaddr;

	memset(dev_priv->hw_status_page, 0, PAGE_SIZE);

	I915_WRITE(HWS_PGA, dev_priv->dma_status_page);
	DRM_DEBUG("Enabled hardware status page\n");
	return 0;
}

/**
 * Frees the hardware status page, whether it's a physical address or a virtual
 * address set up by the X Server.
 */
107
static void i915_free_hws(struct drm_device *dev)
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
{
	drm_i915_private_t *dev_priv = dev->dev_private;
	if (dev_priv->status_page_dmah) {
		drm_pci_free(dev, dev_priv->status_page_dmah);
		dev_priv->status_page_dmah = NULL;
	}

	if (dev_priv->status_gfx_addr) {
		dev_priv->status_gfx_addr = 0;
		drm_core_ioremapfree(&dev_priv->hws_map, dev);
	}

	/* Need to rewrite hardware status page */
	I915_WRITE(HWS_PGA, 0x1ffff000);
}

124
void i915_kernel_lost_context(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
125
126
{
	drm_i915_private_t *dev_priv = dev->dev_private;
127
	struct drm_i915_master_private *master_priv;
Linus Torvalds's avatar
Linus Torvalds committed
128
129
	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);

130
131
132
133
134
135
136
	/*
	 * We should never lose context on the ring with modesetting
	 * as we don't expose it to userspace
	 */
	if (drm_core_check_feature(dev, DRIVER_MODESET))
		return;

137
138
	ring->head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
	ring->tail = I915_READ(PRB0_TAIL) & TAIL_ADDR;
Linus Torvalds's avatar
Linus Torvalds committed
139
140
141
142
	ring->space = ring->head - (ring->tail + 8);
	if (ring->space < 0)
		ring->space += ring->Size;

143
144
145
146
147
148
	if (!dev->primary->master)
		return;

	master_priv = dev->primary->master->driver_priv;
	if (ring->head == ring->tail && master_priv->sarea_priv)
		master_priv->sarea_priv->perf_boxes |= I915_BOX_RING_EMPTY;
Linus Torvalds's avatar
Linus Torvalds committed
149
150
}

151
static int i915_dma_cleanup(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
152
{
153
	drm_i915_private_t *dev_priv = dev->dev_private;
Linus Torvalds's avatar
Linus Torvalds committed
154
155
156
157
	/* Make sure interrupts are disabled here because the uninstall ioctl
	 * may not have been called from userspace and after dev_private
	 * is freed, it's too late.
	 */
158
	if (dev->irq_enabled)
Dave Airlie's avatar
Dave Airlie committed
159
		drm_irq_uninstall(dev);
Linus Torvalds's avatar
Linus Torvalds committed
160

161
162
	if (dev_priv->ring.virtual_start) {
		drm_core_ioremapfree(&dev_priv->ring.map, dev);
163
164
		dev_priv->ring.virtual_start = NULL;
		dev_priv->ring.map.handle = NULL;
165
166
		dev_priv->ring.map.size = 0;
	}
167

168
169
170
	/* Clear the HWS virtual address at teardown */
	if (I915_NEED_GFX_HWS(dev))
		i915_free_hws(dev);
Linus Torvalds's avatar
Linus Torvalds committed
171
172
173
174

	return 0;
}

175
static int i915_initialize(struct drm_device * dev, drm_i915_init_t * init)
Linus Torvalds's avatar
Linus Torvalds committed
176
{
177
	drm_i915_private_t *dev_priv = dev->dev_private;
178
	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
Linus Torvalds's avatar
Linus Torvalds committed
179

180
181
182
183
184
185
186
187
	master_priv->sarea = drm_getsarea(dev);
	if (master_priv->sarea) {
		master_priv->sarea_priv = (drm_i915_sarea_t *)
			((u8 *)master_priv->sarea->handle + init->sarea_priv_offset);
	} else {
		DRM_DEBUG("sarea not found assuming DRI2 userspace\n");
	}

188
189
190
191
192
193
194
	if (init->ring_size != 0) {
		if (dev_priv->ring.ring_obj != NULL) {
			i915_dma_cleanup(dev);
			DRM_ERROR("Client tried to initialize ringbuffer in "
				  "GEM mode\n");
			return -EINVAL;
		}
Linus Torvalds's avatar
Linus Torvalds committed
195

196
197
		dev_priv->ring.Size = init->ring_size;
		dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
Linus Torvalds's avatar
Linus Torvalds committed
198

199
200
201
202
203
		dev_priv->ring.map.offset = init->ring_start;
		dev_priv->ring.map.size = init->ring_size;
		dev_priv->ring.map.type = 0;
		dev_priv->ring.map.flags = 0;
		dev_priv->ring.map.mtrr = 0;
Linus Torvalds's avatar
Linus Torvalds committed
204

205
206
207
208
209
210
211
212
		drm_core_ioremap(&dev_priv->ring.map, dev);

		if (dev_priv->ring.map.handle == NULL) {
			i915_dma_cleanup(dev);
			DRM_ERROR("can not ioremap virtual address for"
				  " ring buffer\n");
			return -ENOMEM;
		}
Linus Torvalds's avatar
Linus Torvalds committed
213
214
215
216
	}

	dev_priv->ring.virtual_start = dev_priv->ring.map.handle;

217
	dev_priv->cpp = init->cpp;
Linus Torvalds's avatar
Linus Torvalds committed
218
219
220
	dev_priv->back_offset = init->back_offset;
	dev_priv->front_offset = init->front_offset;
	dev_priv->current_page = 0;
221
222
	if (master_priv->sarea_priv)
		master_priv->sarea_priv->pf_current_page = 0;
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
226
227
228
229
230

	/* Allow hardware batchbuffers unless told otherwise.
	 */
	dev_priv->allow_batchbuffer = 1;

	return 0;
}

231
static int i915_dma_resume(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
232
233
234
{
	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;

235
	DRM_DEBUG("%s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
236
237
238
239

	if (dev_priv->ring.map.handle == NULL) {
		DRM_ERROR("can not ioremap virtual address for"
			  " ring buffer\n");
Eric Anholt's avatar
Eric Anholt committed
240
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
241
242
243
244
245
	}

	/* Program Hardware Status Page */
	if (!dev_priv->hw_status_page) {
		DRM_ERROR("Can not find hardware status page\n");
Eric Anholt's avatar
Eric Anholt committed
246
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
247
248
249
	}
	DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page);

250
	if (dev_priv->status_gfx_addr != 0)
251
		I915_WRITE(HWS_PGA, dev_priv->status_gfx_addr);
252
	else
253
		I915_WRITE(HWS_PGA, dev_priv->dma_status_page);
Linus Torvalds's avatar
Linus Torvalds committed
254
255
256
257
258
	DRM_DEBUG("Enabled hardware status page\n");

	return 0;
}

259
260
static int i915_dma_init(struct drm_device *dev, void *data,
			 struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
261
{
262
	drm_i915_init_t *init = data;
Linus Torvalds's avatar
Linus Torvalds committed
263
264
	int retcode = 0;

265
	switch (init->func) {
Linus Torvalds's avatar
Linus Torvalds committed
266
	case I915_INIT_DMA:
267
		retcode = i915_initialize(dev, init);
Linus Torvalds's avatar
Linus Torvalds committed
268
269
270
271
272
		break;
	case I915_CLEANUP_DMA:
		retcode = i915_dma_cleanup(dev);
		break;
	case I915_RESUME_DMA:
Dave Airlie's avatar
Dave Airlie committed
273
		retcode = i915_dma_resume(dev);
Linus Torvalds's avatar
Linus Torvalds committed
274
275
		break;
	default:
Eric Anholt's avatar
Eric Anholt committed
276
		retcode = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
		break;
	}

	return retcode;
}

/* Implement basically the same security restrictions as hardware does
 * for MI_BATCH_NON_SECURE.  These can be made stricter at any time.
 *
 * Most of the calculations below involve calculating the size of a
 * particular instruction.  It's important to get the size right as
 * that tells us where the next instruction to check is.  Any illegal
 * instruction detected will be given a size of zero, which is a
 * signal to abort the rest of the buffer.
 */
static int do_validate_cmd(int cmd)
{
	switch (((cmd >> 29) & 0x7)) {
	case 0x0:
		switch ((cmd >> 23) & 0x3f) {
		case 0x0:
			return 1;	/* MI_NOOP */
		case 0x4:
			return 1;	/* MI_FLUSH */
		default:
			return 0;	/* disallow everything else */
		}
		break;
	case 0x1:
		return 0;	/* reserved */
	case 0x2:
		return (cmd & 0xff) + 2;	/* 2d commands */
	case 0x3:
		if (((cmd >> 24) & 0x1f) <= 0x18)
			return 1;

		switch ((cmd >> 24) & 0x1f) {
		case 0x1c:
			return 1;
		case 0x1d:
Dave Airlie's avatar
Dave Airlie committed
317
			switch ((cmd >> 16) & 0xff) {
Linus Torvalds's avatar
Linus Torvalds committed
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
			case 0x3:
				return (cmd & 0x1f) + 2;
			case 0x4:
				return (cmd & 0xf) + 2;
			default:
				return (cmd & 0xffff) + 2;
			}
		case 0x1e:
			if (cmd & (1 << 23))
				return (cmd & 0xffff) + 1;
			else
				return 1;
		case 0x1f:
			if ((cmd & (1 << 23)) == 0)	/* inline vertices */
				return (cmd & 0x1ffff) + 2;
			else if (cmd & (1 << 17))	/* indirect random */
				if ((cmd & 0xffff) == 0)
					return 0;	/* unknown length, too hard */
				else
					return (((cmd & 0xffff) + 1) / 2) + 1;
			else
				return 2;	/* indirect sequential */
		default:
			return 0;
		}
	default:
		return 0;
	}

	return 0;
}

static int validate_cmd(int cmd)
{
	int ret = do_validate_cmd(cmd);

354
/*	printk("validate_cmd( %x ): %d\n", cmd, ret); */
Linus Torvalds's avatar
Linus Torvalds committed
355
356
357
358

	return ret;
}

359
static int i915_emit_cmds(struct drm_device * dev, int __user * buffer, int dwords)
Linus Torvalds's avatar
Linus Torvalds committed
360
361
362
363
364
{
	drm_i915_private_t *dev_priv = dev->dev_private;
	int i;
	RING_LOCALS;

365
	if ((dwords+1) * sizeof(int) >= dev_priv->ring.Size - 8)
Eric Anholt's avatar
Eric Anholt committed
366
		return -EINVAL;
367

368
	BEGIN_LP_RING((dwords+1)&~1);
369

Linus Torvalds's avatar
Linus Torvalds committed
370
371
372
373
	for (i = 0; i < dwords;) {
		int cmd, sz;

		if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i], sizeof(cmd)))
Eric Anholt's avatar
Eric Anholt committed
374
			return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
375
376

		if ((sz = validate_cmd(cmd)) == 0 || i + sz > dwords)
Eric Anholt's avatar
Eric Anholt committed
377
			return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
378
379
380
381
382
383

		OUT_RING(cmd);

		while (++i, --sz) {
			if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i],
							 sizeof(cmd))) {
Eric Anholt's avatar
Eric Anholt committed
384
				return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
385
386
387
388
389
			}
			OUT_RING(cmd);
		}
	}

390
391
392
393
394
	if (dwords & 1)
		OUT_RING(0);

	ADVANCE_LP_RING();

Linus Torvalds's avatar
Linus Torvalds committed
395
396
397
	return 0;
}

398
399
400
401
int
i915_emit_box(struct drm_device *dev,
	      struct drm_clip_rect __user *boxes,
	      int i, int DR1, int DR4)
Linus Torvalds's avatar
Linus Torvalds committed
402
403
{
	drm_i915_private_t *dev_priv = dev->dev_private;
404
	struct drm_clip_rect box;
Linus Torvalds's avatar
Linus Torvalds committed
405
406
407
	RING_LOCALS;

	if (DRM_COPY_FROM_USER_UNCHECKED(&box, &boxes[i], sizeof(box))) {
Eric Anholt's avatar
Eric Anholt committed
408
		return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
409
410
411
412
413
	}

	if (box.y2 <= box.y1 || box.x2 <= box.x1 || box.y2 <= 0 || box.x2 <= 0) {
		DRM_ERROR("Bad box %d,%d..%d,%d\n",
			  box.x1, box.y1, box.x2, box.y2);
Eric Anholt's avatar
Eric Anholt committed
414
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
415
416
	}

417
418
419
420
	if (IS_I965G(dev)) {
		BEGIN_LP_RING(4);
		OUT_RING(GFX_OP_DRAWRECT_INFO_I965);
		OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
Andrew Morton's avatar
Andrew Morton committed
421
		OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
422
423
424
425
426
427
428
429
430
431
432
433
		OUT_RING(DR4);
		ADVANCE_LP_RING();
	} else {
		BEGIN_LP_RING(6);
		OUT_RING(GFX_OP_DRAWRECT_INFO);
		OUT_RING(DR1);
		OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
		OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
		OUT_RING(DR4);
		OUT_RING(0);
		ADVANCE_LP_RING();
	}
Linus Torvalds's avatar
Linus Torvalds committed
434
435
436
437

	return 0;
}

438
439
440
441
/* XXX: Emitting the counter should really be moved to part of the IRQ
 * emit. For now, do it in both places:
 */

442
static void i915_emit_breadcrumb(struct drm_device *dev)
443
444
{
	drm_i915_private_t *dev_priv = dev->dev_private;
445
	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
446
447
	RING_LOCALS;

448
	dev_priv->counter++;
449
	if (dev_priv->counter > 0x7FFFFFFFUL)
450
		dev_priv->counter = 0;
451
452
	if (master_priv->sarea_priv)
		master_priv->sarea_priv->last_enqueue = dev_priv->counter;
453
454

	BEGIN_LP_RING(4);
455
	OUT_RING(MI_STORE_DWORD_INDEX);
456
	OUT_RING(I915_BREADCRUMB_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
457
458
459
460
461
	OUT_RING(dev_priv->counter);
	OUT_RING(0);
	ADVANCE_LP_RING();
}

462
static int i915_dispatch_cmdbuffer(struct drm_device * dev,
Linus Torvalds's avatar
Linus Torvalds committed
463
464
465
466
467
468
469
				   drm_i915_cmdbuffer_t * cmd)
{
	int nbox = cmd->num_cliprects;
	int i = 0, count, ret;

	if (cmd->sz & 0x3) {
		DRM_ERROR("alignment");
Eric Anholt's avatar
Eric Anholt committed
470
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
	}

	i915_kernel_lost_context(dev);

	count = nbox ? nbox : 1;

	for (i = 0; i < count; i++) {
		if (i < nbox) {
			ret = i915_emit_box(dev, cmd->cliprects, i,
					    cmd->DR1, cmd->DR4);
			if (ret)
				return ret;
		}

		ret = i915_emit_cmds(dev, (int __user *)cmd->buf, cmd->sz / 4);
		if (ret)
			return ret;
	}

490
	i915_emit_breadcrumb(dev);
Linus Torvalds's avatar
Linus Torvalds committed
491
492
493
	return 0;
}

494
static int i915_dispatch_batchbuffer(struct drm_device * dev,
Linus Torvalds's avatar
Linus Torvalds committed
495
496
497
				     drm_i915_batchbuffer_t * batch)
{
	drm_i915_private_t *dev_priv = dev->dev_private;
498
	struct drm_clip_rect __user *boxes = batch->cliprects;
Linus Torvalds's avatar
Linus Torvalds committed
499
500
501
502
503
504
	int nbox = batch->num_cliprects;
	int i = 0, count;
	RING_LOCALS;

	if ((batch->start | batch->used) & 0x7) {
		DRM_ERROR("alignment");
Eric Anholt's avatar
Eric Anholt committed
505
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
506
507
508
509
510
511
512
513
514
515
516
517
518
519
	}

	i915_kernel_lost_context(dev);

	count = nbox ? nbox : 1;

	for (i = 0; i < count; i++) {
		if (i < nbox) {
			int ret = i915_emit_box(dev, boxes, i,
						batch->DR1, batch->DR4);
			if (ret)
				return ret;
		}

520
		if (!IS_I830(dev) && !IS_845G(dev)) {
Linus Torvalds's avatar
Linus Torvalds committed
521
			BEGIN_LP_RING(2);
522
523
524
525
526
527
528
			if (IS_I965G(dev)) {
				OUT_RING(MI_BATCH_BUFFER_START | (2 << 6) | MI_BATCH_NON_SECURE_I965);
				OUT_RING(batch->start);
			} else {
				OUT_RING(MI_BATCH_BUFFER_START | (2 << 6));
				OUT_RING(batch->start | MI_BATCH_NON_SECURE);
			}
Linus Torvalds's avatar
Linus Torvalds committed
529
530
531
532
533
534
535
536
537
538
539
			ADVANCE_LP_RING();
		} else {
			BEGIN_LP_RING(4);
			OUT_RING(MI_BATCH_BUFFER);
			OUT_RING(batch->start | MI_BATCH_NON_SECURE);
			OUT_RING(batch->start + batch->used - 4);
			OUT_RING(0);
			ADVANCE_LP_RING();
		}
	}

540
	i915_emit_breadcrumb(dev);
Linus Torvalds's avatar
Linus Torvalds committed
541
542
543
544

	return 0;
}

545
static int i915_dispatch_flip(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
546
547
{
	drm_i915_private_t *dev_priv = dev->dev_private;
548
549
	struct drm_i915_master_private *master_priv =
		dev->primary->master->driver_priv;
Linus Torvalds's avatar
Linus Torvalds committed
550
551
	RING_LOCALS;

552
	if (!master_priv->sarea_priv)
553
554
		return -EINVAL;

555
	DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n",
556
		  __func__,
557
		  dev_priv->current_page,
558
		  master_priv->sarea_priv->pf_current_page);
Linus Torvalds's avatar
Linus Torvalds committed
559

560
561
562
	i915_kernel_lost_context(dev);

	BEGIN_LP_RING(2);
563
	OUT_RING(MI_FLUSH | MI_READ_FLUSH);
564
565
	OUT_RING(0);
	ADVANCE_LP_RING();
Linus Torvalds's avatar
Linus Torvalds committed
566

567
568
569
570
571
572
	BEGIN_LP_RING(6);
	OUT_RING(CMD_OP_DISPLAYBUFFER_INFO | ASYNC_FLIP);
	OUT_RING(0);
	if (dev_priv->current_page == 0) {
		OUT_RING(dev_priv->back_offset);
		dev_priv->current_page = 1;
Linus Torvalds's avatar
Linus Torvalds committed
573
	} else {
574
575
		OUT_RING(dev_priv->front_offset);
		dev_priv->current_page = 0;
Linus Torvalds's avatar
Linus Torvalds committed
576
	}
577
578
	OUT_RING(0);
	ADVANCE_LP_RING();
Linus Torvalds's avatar
Linus Torvalds committed
579

580
581
582
583
	BEGIN_LP_RING(2);
	OUT_RING(MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_A_FLIP);
	OUT_RING(0);
	ADVANCE_LP_RING();
Linus Torvalds's avatar
Linus Torvalds committed
584

585
	master_priv->sarea_priv->last_enqueue = dev_priv->counter++;
Linus Torvalds's avatar
Linus Torvalds committed
586
587

	BEGIN_LP_RING(4);
588
	OUT_RING(MI_STORE_DWORD_INDEX);
589
	OUT_RING(I915_BREADCRUMB_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
590
591
	OUT_RING(dev_priv->counter);
	OUT_RING(0);
Linus Torvalds's avatar
Linus Torvalds committed
592
593
	ADVANCE_LP_RING();

594
	master_priv->sarea_priv->pf_current_page = dev_priv->current_page;
595
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
596
597
}

598
static int i915_quiescent(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
599
600
601
602
{
	drm_i915_private_t *dev_priv = dev->dev_private;

	i915_kernel_lost_context(dev);
603
	return i915_wait_ring(dev, dev_priv->ring.Size - 8, __func__);
Linus Torvalds's avatar
Linus Torvalds committed
604
605
}

606
607
static int i915_flush_ioctl(struct drm_device *dev, void *data,
			    struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
608
{
609
610
611
	int ret;

	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
Linus Torvalds's avatar
Linus Torvalds committed
612

613
614
615
616
617
	mutex_lock(&dev->struct_mutex);
	ret = i915_quiescent(dev);
	mutex_unlock(&dev->struct_mutex);

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
618
619
}

620
621
static int i915_batchbuffer(struct drm_device *dev, void *data,
			    struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
622
623
{
	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
624
	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
Linus Torvalds's avatar
Linus Torvalds committed
625
	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
626
	    master_priv->sarea_priv;
627
	drm_i915_batchbuffer_t *batch = data;
Linus Torvalds's avatar
Linus Torvalds committed
628
629
630
631
	int ret;

	if (!dev_priv->allow_batchbuffer) {
		DRM_ERROR("Batchbuffer ioctl disabled\n");
Eric Anholt's avatar
Eric Anholt committed
632
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
633
634
635
	}

	DRM_DEBUG("i915 batchbuffer, start %x used %d cliprects %d\n",
636
		  batch->start, batch->used, batch->num_cliprects);
Linus Torvalds's avatar
Linus Torvalds committed
637

638
	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
Linus Torvalds's avatar
Linus Torvalds committed
639

640
641
	if (batch->num_cliprects && DRM_VERIFYAREA_READ(batch->cliprects,
						       batch->num_cliprects *
642
						       sizeof(struct drm_clip_rect)))
Eric Anholt's avatar
Eric Anholt committed
643
		return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
644

645
	mutex_lock(&dev->struct_mutex);
646
	ret = i915_dispatch_batchbuffer(dev, batch);
647
	mutex_unlock(&dev->struct_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
648

649
	if (sarea_priv)
650
		sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
	return ret;
}

654
655
static int i915_cmdbuffer(struct drm_device *dev, void *data,
			  struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
656
657
{
	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
658
	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
Linus Torvalds's avatar
Linus Torvalds committed
659
	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
660
	    master_priv->sarea_priv;
661
	drm_i915_cmdbuffer_t *cmdbuf = data;
Linus Torvalds's avatar
Linus Torvalds committed
662
663
664
	int ret;

	DRM_DEBUG("i915 cmdbuffer, buf %p sz %d cliprects %d\n",
665
		  cmdbuf->buf, cmdbuf->sz, cmdbuf->num_cliprects);
Linus Torvalds's avatar
Linus Torvalds committed
666

667
	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
Linus Torvalds's avatar
Linus Torvalds committed
668

669
670
671
	if (cmdbuf->num_cliprects &&
	    DRM_VERIFYAREA_READ(cmdbuf->cliprects,
				cmdbuf->num_cliprects *
672
				sizeof(struct drm_clip_rect))) {
Linus Torvalds's avatar
Linus Torvalds committed
673
		DRM_ERROR("Fault accessing cliprects\n");
Eric Anholt's avatar
Eric Anholt committed
674
		return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
675
676
	}

677
	mutex_lock(&dev->struct_mutex);
678
	ret = i915_dispatch_cmdbuffer(dev, cmdbuf);
679
	mutex_unlock(&dev->struct_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
680
681
682
683
684
	if (ret) {
		DRM_ERROR("i915_dispatch_cmdbuffer failed\n");
		return ret;
	}

685
	if (sarea_priv)
686
		sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
Linus Torvalds's avatar
Linus Torvalds committed
687
688
689
	return 0;
}

690
691
static int i915_flip_bufs(struct drm_device *dev, void *data,
			  struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
692
{
693
694
	int ret;

695
	DRM_DEBUG("%s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
696

697
	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
Linus Torvalds's avatar
Linus Torvalds committed
698

699
700
701
702
703
	mutex_lock(&dev->struct_mutex);
	ret = i915_dispatch_flip(dev);
	mutex_unlock(&dev->struct_mutex);

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
704
705
}

706
707
static int i915_getparam(struct drm_device *dev, void *data,
			 struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
708
709
{
	drm_i915_private_t *dev_priv = dev->dev_private;
710
	drm_i915_getparam_t *param = data;
Linus Torvalds's avatar
Linus Torvalds committed
711
712
713
	int value;

	if (!dev_priv) {
714
		DRM_ERROR("called with no initialization\n");
Eric Anholt's avatar
Eric Anholt committed
715
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
716
717
	}

718
	switch (param->param) {
Linus Torvalds's avatar
Linus Torvalds committed
719
	case I915_PARAM_IRQ_ACTIVE:
720
		value = dev->pdev->irq ? 1 : 0;
Linus Torvalds's avatar
Linus Torvalds committed
721
722
723
724
		break;
	case I915_PARAM_ALLOW_BATCHBUFFER:
		value = dev_priv->allow_batchbuffer ? 1 : 0;
		break;
Dave Airlie's avatar
Dave Airlie committed
725
726
727
	case I915_PARAM_LAST_DISPATCH:
		value = READ_BREADCRUMB(dev_priv);
		break;
728
729
730
	case I915_PARAM_CHIPSET_ID:
		value = dev->pci_device;
		break;
731
	case I915_PARAM_HAS_GEM:
732
		value = dev_priv->has_gem;
733
		break;
734
735
736
	case I915_PARAM_NUM_FENCES_AVAIL:
		value = dev_priv->num_fence_regs - dev_priv->fence_reg_start;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
737
	default:
738
		DRM_DEBUG("Unknown parameter %d\n", param->param);
Eric Anholt's avatar
Eric Anholt committed
739
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
740
741
	}

742
	if (DRM_COPY_TO_USER(param->value, &value, sizeof(int))) {
Linus Torvalds's avatar
Linus Torvalds committed
743
		DRM_ERROR("DRM_COPY_TO_USER failed\n");
Eric Anholt's avatar
Eric Anholt committed
744
		return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
745
746
747
748
749
	}

	return 0;
}

750
751
static int i915_setparam(struct drm_device *dev, void *data,
			 struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
752
753
{
	drm_i915_private_t *dev_priv = dev->dev_private;
754
	drm_i915_setparam_t *param = data;
Linus Torvalds's avatar
Linus Torvalds committed
755
756

	if (!dev_priv) {
757
		DRM_ERROR("called with no initialization\n");
Eric Anholt's avatar
Eric Anholt committed
758
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
759
760
	}

761
	switch (param->param) {
Linus Torvalds's avatar
Linus Torvalds committed
762
763
764
	case I915_SETPARAM_USE_MI_BATCHBUFFER_START:
		break;
	case I915_SETPARAM_TEX_LRU_LOG_GRANULARITY:
765
		dev_priv->tex_lru_log_granularity = param->value;
Linus Torvalds's avatar
Linus Torvalds committed
766
767
		break;
	case I915_SETPARAM_ALLOW_BATCHBUFFER:
768
		dev_priv->allow_batchbuffer = param->value;
Linus Torvalds's avatar
Linus Torvalds committed
769
		break;
770
771
772
773
774
775
776
	case I915_SETPARAM_NUM_USED_FENCES:
		if (param->value > dev_priv->num_fence_regs ||
		    param->value < 0)
			return -EINVAL;
		/* Userspace can use first N regs */
		dev_priv->fence_reg_start = param->value;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
777
	default:
778
		DRM_DEBUG("unknown parameter %d\n", param->param);
Eric Anholt's avatar
Eric Anholt committed
779
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
780
781
782
783
784
	}

	return 0;
}

785
786
static int i915_set_status_page(struct drm_device *dev, void *data,
				struct drm_file *file_priv)
787
788
{
	drm_i915_private_t *dev_priv = dev->dev_private;
789
	drm_i915_hws_addr_t *hws = data;
790
791
792

	if (!I915_NEED_GFX_HWS(dev))
		return -EINVAL;
793
794

	if (!dev_priv) {
795
		DRM_ERROR("called with no initialization\n");
Eric Anholt's avatar
Eric Anholt committed
796
		return -EINVAL;
797
798
	}

799
800
801
802
803
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		WARN(1, "tried to set status page when mode setting active\n");
		return 0;
	}

804
805
806
	printk(KERN_DEBUG "set status page addr 0x%08x\n", (u32)hws->addr);

	dev_priv->status_gfx_addr = hws->addr & (0x1ffff<<12);
807

808
	dev_priv->hws_map.offset = dev->agp->base + hws->addr;
809
810
811
812
813
814
815
816
817
818
819
	dev_priv->hws_map.size = 4*1024;
	dev_priv->hws_map.type = 0;
	dev_priv->hws_map.flags = 0;
	dev_priv->hws_map.mtrr = 0;

	drm_core_ioremap(&dev_priv->hws_map, dev);
	if (dev_priv->hws_map.handle == NULL) {
		i915_dma_cleanup(dev);
		dev_priv->status_gfx_addr = 0;
		DRM_ERROR("can not ioremap virtual address for"
				" G33 hw status page\n");
Eric Anholt's avatar
Eric Anholt committed
820
		return -ENOMEM;
821
822
823
824
	}
	dev_priv->hw_status_page = dev_priv->hws_map.handle;

	memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
825
826
	I915_WRITE(HWS_PGA, dev_priv->status_gfx_addr);
	DRM_DEBUG("load hws HWS_PGA with gfx mem 0x%x\n",
827
828
829
830
831
			dev_priv->status_gfx_addr);
	DRM_DEBUG("load hws at %p\n", dev_priv->hw_status_page);
	return 0;
}

832
833
834
835
836
837
838
839
840
841
/**
 * i915_probe_agp - get AGP bootup configuration
 * @pdev: PCI device
 * @aperture_size: returns AGP aperture configured size
 * @preallocated_size: returns size of BIOS preallocated AGP space
 *
 * Since Intel integrated graphics are UMA, the BIOS has to set aside
 * some RAM for the framebuffer at early boot.  This code figures out
 * how much was set aside so we can use it for our own purposes.
 */
842
843
static int i915_probe_agp(struct drm_device *dev, unsigned long *aperture_size,
			  unsigned long *preallocated_size)
844
845
846
847
{
	struct pci_dev *bridge_dev;
	u16 tmp = 0;
	unsigned long overhead;
848
	unsigned long stolen;
849
850
851
852
853
854
855
856
857
858
859
860
861
862

	bridge_dev = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
	if (!bridge_dev) {
		DRM_ERROR("bridge device not found\n");
		return -1;
	}

	/* Get the fb aperture size and "stolen" memory amount. */
	pci_read_config_word(bridge_dev, INTEL_GMCH_CTRL, &tmp);
	pci_dev_put(bridge_dev);

	*aperture_size = 1024 * 1024;
	*preallocated_size = 1024 * 1024;

863
	switch (dev->pdev->device) {
864
865
866
867
868
869
870
871
872
873
874
	case PCI_DEVICE_ID_INTEL_82830_CGC:
	case PCI_DEVICE_ID_INTEL_82845G_IG:
	case PCI_DEVICE_ID_INTEL_82855GM_IG:
	case PCI_DEVICE_ID_INTEL_82865_IG:
		if ((tmp & INTEL_GMCH_MEM_MASK) == INTEL_GMCH_MEM_64M)
			*aperture_size *= 64;
		else
			*aperture_size *= 128;
		break;
	default:
		/* 9xx supports large sizes, just look at the length */
875
		*aperture_size = pci_resource_len(dev->pdev, 2);
876
877
878
879
880
881
882
		break;
	}

	/*
	 * Some of the preallocated space is taken by the GTT
	 * and popup.  GTT is 1K per MB of aperture size, and popup is 4K.
	 */
883
884
885
886
887
	if (IS_G4X(dev))
		overhead = 4096;
	else
		overhead = (*aperture_size / 1024) + 4096;

888
889
890
891
	switch (tmp & INTEL_GMCH_GMS_MASK) {
	case INTEL_855_GMCH_GMS_DISABLED:
		DRM_ERROR("video memory is disabled\n");
		return -1;
892
	case INTEL_855_GMCH_GMS_STOLEN_1M:
893
894
		stolen = 1 * 1024 * 1024;
		break;
895
	case INTEL_855_GMCH_GMS_STOLEN_4M:
896
		stolen = 4 * 1024 * 1024;
897
898
		break;
	case INTEL_855_GMCH_GMS_STOLEN_8M:
899
		stolen = 8 * 1024 * 1024;
900
901
		break;
	case INTEL_855_GMCH_GMS_STOLEN_16M:
902
		stolen = 16 * 1024 * 1024;
903
904
		break;
	case INTEL_855_GMCH_GMS_STOLEN_32M:
905
		stolen = 32 * 1024 * 1024;
906
907
		break;
	case INTEL_915G_GMCH_GMS_STOLEN_48M:
908
		stolen = 48 * 1024 * 1024;
909
910
		break;
	case INTEL_915G_GMCH_GMS_STOLEN_64M:
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
		stolen = 64 * 1024 * 1024;
		break;
	case INTEL_GMCH_GMS_STOLEN_128M:
		stolen = 128 * 1024 * 1024;
		break;
	case INTEL_GMCH_GMS_STOLEN_256M:
		stolen = 256 * 1024 * 1024;
		break;
	case INTEL_GMCH_GMS_STOLEN_96M:
		stolen = 96 * 1024 * 1024;
		break;
	case INTEL_GMCH_GMS_STOLEN_160M:
		stolen = 160 * 1024 * 1024;
		break;
	case INTEL_GMCH_GMS_STOLEN_224M:
		stolen = 224 * 1024 * 1024;
		break;
	case INTEL_GMCH_GMS_STOLEN_352M:
		stolen = 352 * 1024 * 1024;
930
931
932
		break;
	default:
		DRM_ERROR("unexpected GMCH_GMS value: 0x%02x\n",
933
			tmp & INTEL_GMCH_GMS_MASK);
934
935
		return -1;
	}
936
	*preallocated_size = stolen - overhead;
937
938
939
940
941
942
943
944
945
946
947

	return 0;
}

static int i915_load_modeset_init(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	unsigned long agp_size, prealloc_size;
	int fb_bar = IS_I9XX(dev) ? 2 : 0;
	int ret = 0;

948
949
950
951
952
953
	dev->devname = kstrdup(DRIVER_NAME, GFP_KERNEL);
	if (!dev->devname) {
		ret = -ENOMEM;
		goto out;
	}

954
955
956
	dev->mode_config.fb_base = drm_get_resource_start(dev, fb_bar) &
		0xff000000;

957
	if (IS_MOBILE(dev) || IS_I9XX(dev))
958
959
960
961
		dev_priv->cursor_needs_physical = true;
	else
		dev_priv->cursor_needs_physical = false;

962
963
964
	if (IS_I965G(dev) || IS_G33(dev))
		dev_priv->cursor_needs_physical = false;

965
966
967
	ret = i915_probe_agp(dev, &agp_size, &prealloc_size);
	if (ret)
		goto kfree_devname;
968
969
970
971
972
973
974
975
976

	/* Basic memrange allocator for stolen space (aka vram) */
	drm_mm_init(&dev_priv->vram, 0, prealloc_size);

	/* Let GEM Manage from end of prealloc space to end of aperture */
	i915_gem_do_init(dev, prealloc_size, agp_size);

	ret = i915_gem_init_ringbuffer(dev);
	if (ret)
977
		goto kfree_devname;
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015

	/* Allow hardware batchbuffers unless told otherwise.
	 */
	dev_priv->allow_batchbuffer = 1;

	ret = intel_init_bios(dev);
	if (ret)
		DRM_INFO("failed to find VBIOS tables\n");

	ret = drm_irq_install(dev);
	if (ret)
		goto destroy_ringbuffer;

	/* FIXME: re-add hotplug support */
#if 0
	ret = drm_hotplug_init(dev);
	if (ret)
		goto destroy_ringbuffer;
#endif

	/* Always safe in the mode setting case. */
	/* FIXME: do pre/post-mode set stuff in core KMS code */
	dev->vblank_disable_allowed = 1;

	/*
	 * Initialize the hardware status page IRQ location.
	 */

	I915_WRITE(INSTPM, (1 << 5) | (1 << 21));

	intel_modeset_init(dev);

	drm_helper_initial_config(dev, false);

	return 0;

destroy_ringbuffer:
	i915_gem_cleanup_ringbuffer(dev);
1016
1017
kfree_devname:
	kfree(dev->devname);
1018
1019
1020
1021
out:
	return ret;
}

1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
int i915_master_create(struct drm_device *dev, struct drm_master *master)
{
	struct drm_i915_master_private *master_priv;

	master_priv = drm_calloc(1, sizeof(*master_priv), DRM_MEM_DRIVER);
	if (!master_priv)
		return -ENOMEM;

	master->driver_priv = master_priv;
	return 0;
}

void i915_master_destroy(struct drm_device *dev, struct drm_master *master)
{
	struct drm_i915_master_private *master_priv = master->driver_priv;

	if (!master_priv)
		return;

	drm_free(master_priv, sizeof(*master_priv), DRM_MEM_DRIVER);

	master->driver_priv = NULL;
}

1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
/**
 * i915_driver_load - setup chip and create an initial config
 * @dev: DRM device
 * @flags: startup flags
 *
 * The driver load routine has to do several things:
 *   - drive output discovery via intel_modeset_init()
 *   - initialize the memory manager
 *   - allocate initial config memory
 *   - setup the DRM framebuffer with the allocated memory
 */
1057
int i915_driver_load(struct drm_device *dev, unsigned long flags)
1058
{
1059
1060
1061
1062
	struct drm_i915_private *dev_priv = dev->dev_private;
	unsigned long base, size;
	int ret = 0, mmio_bar = IS_I9XX(dev) ? 0 : 1;

1063
1064
1065
1066
1067
1068
1069
	/* i915 has 4 more counters */
	dev->counters += 4;
	dev->types[6] = _DRM_STAT_IRQ;
	dev->types[7] = _DRM_STAT_PRIMARY;
	dev->types[8] = _DRM_STAT_SECONDARY;
	dev->types[9] = _DRM_STAT_DMA;

1070
1071
1072
1073
1074
1075
1076
	dev_priv = drm_alloc(sizeof(drm_i915_private_t), DRM_MEM_DRIVER);
	if (dev_priv == NULL)
		return -ENOMEM;

	memset(dev_priv, 0, sizeof(drm_i915_private_t));

	dev->dev_private = (void *)dev_priv;
1077
	dev_priv->dev = dev;
1078
1079
1080
1081
1082

	/* Add register map (needed for suspend/resume) */
	base = drm_get_resource_start(dev, mmio_bar);
	size = drm_get_resource_len(dev, mmio_bar);

1083
	dev_priv->regs = ioremap(base, size);
1084
1085
1086
1087
1088
	if (!dev_priv->regs) {
		DRM_ERROR("failed to map registers\n");
		ret = -EIO;
		goto free_priv;
	}
1089

1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
        dev_priv->mm.gtt_mapping =
		io_mapping_create_wc(dev->agp->base,
				     dev->agp->agp_info.aper_size * 1024*1024);
	/* Set up a WC MTRR for non-PAT systems.  This is more common than
	 * one would think, because the kernel disables PAT on first
	 * generation Core chips because WC PAT gets overridden by a UC
	 * MTRR if present.  Even if a UC MTRR isn't present.
	 */
	dev_priv->mm.gtt_mtrr = mtrr_add(dev->agp->base,
					 dev->agp->agp_info.aper_size *
					 1024 * 1024,
					 MTRR_TYPE_WRCOMB, 1);
	if (dev_priv->mm.gtt_mtrr < 0) {
		DRM_INFO("MTRR allocation failed\n.  Graphics "
			 "performance may suffer.\n");
	}

1107
1108
1109
1110
1111
1112
1113
1114
#ifdef CONFIG_HIGHMEM64G
	/* don't enable GEM on PAE - needs agp + set_memory_* interface fixes */
	dev_priv->has_gem = 0;
#else
	/* enable GEM by default */
	dev_priv->has_gem = 1;
#endif

1115
1116
1117
1118
	dev->driver->get_vblank_counter = i915_get_vblank_counter;
	if (IS_GM45(dev))
		dev->driver->get_vblank_counter = gm45_get_vblank_counter;

1119
1120
	i915_gem_load(dev);

1121
1122
1123
1124
	/* Init HWS */
	if (!I915_NEED_GFX_HWS(dev)) {
		ret = i915_init_phys_hws(dev);
		if (ret != 0)
1125
			goto out_rmmap;
1126
	}
1127
1128
1129
1130
1131
1132
1133

	/* On the 945G/GM, the chipset reports the MSI capability on the
	 * integrated graphics even though the support isn't actually there
	 * according to the published specs.  It doesn't appear to function
	 * correctly in testing on 945G.
	 * This may be a side effect of MSI having been made available for PEG
	 * and the registers being closely associated.
1134
1135
	 *
	 * According to chipset errata, on the 965GM, MSI interrupts may
1136
1137
	 * be lost or delayed, but we use them anyways to avoid
	 * stuck interrupts on some machines.
1138
	 */
1139
	if (!IS_I945G(dev) && !IS_I945GM(dev))
1140
		pci_enable_msi(dev->pdev);
1141

1142
1143
	intel_opregion_init(dev);

1144
	spin_lock_init(&dev_priv->user_irq_lock);
1145
	dev_priv->user_irq_refcount = 0;
1146

1147
1148
1149
1150
1151
1152
1153
	ret = drm_vblank_init(dev, I915_NUM_PIPE);

	if (ret) {
		(void) i915_driver_unload(dev);
		return ret;
	}

1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		ret = i915_load_modeset_init(dev);
		if (ret < 0) {
			DRM_ERROR("failed to init modeset\n");
			goto out_rmmap;
		}
	}

	return 0;

out_rmmap:
	iounmap(dev_priv->regs);
free_priv:
	drm_free(dev_priv, sizeof(struct drm_i915_private), DRM_MEM_DRIVER);
1168
1169
1170
1171
1172
1173
1174
	return ret;
}

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

1175
1176
1177
1178
1179
1180
1181
	io_mapping_free(dev_priv->mm.gtt_mapping);
	if (dev_priv->mm.gtt_mtrr >= 0) {
		mtrr_del(dev_priv->mm.gtt_mtrr, dev->agp->base,
			 dev->agp->agp_info.aper_size * 1024 * 1024);
		dev_priv->mm.gtt_mtrr = -1;
	}

1182
1183
1184
1185
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		drm_irq_uninstall(dev);
	}

1186
1187
1188
	if (dev->pdev->msi_enabled)
		pci_disable_msi(dev->pdev);

1189
1190
	if (dev_priv->regs != NULL)
		iounmap(dev_priv->regs);
1191

1192
1193
	intel_opregion_free(dev);

1194
1195
1196
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		intel_modeset_cleanup(dev);

1197
1198
		i915_gem_free_all_phys_object(dev);

1199
1200
1201
1202
1203
1204
1205
		mutex_lock(&dev->struct_mutex);
		i915_gem_cleanup_ringbuffer(dev);
		mutex_unlock(&dev->struct_mutex);
		drm_mm_takedown(&dev_priv->vram);
		i915_gem_lastclose(dev);
	}

1206
1207
1208
	drm_free(dev->dev_private, sizeof(drm_i915_private_t),
		 DRM_MEM_DRIVER);

1209
1210
1211
	return 0;
}

1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
int i915_driver_open(struct drm_device *dev, struct drm_file *file_priv)
{
	struct drm_i915_file_private *i915_file_priv;

	DRM_DEBUG("\n");
	i915_file_priv = (struct drm_i915_file_private *)
	    drm_alloc(sizeof(*i915_file_priv), DRM_MEM_FILES);

	if (!i915_file_priv)
		return -ENOMEM;

	file_priv->driver_priv = i915_file_priv;

	i915_file_priv->mm.last_gem_seqno = 0;
	i915_file_priv->mm.last_gem_throttle_seqno = 0;

	return 0;
}

1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
/**
 * i915_driver_lastclose - clean up after all DRM clients have exited
 * @dev: DRM device
 *
 * Take care of cleaning up after all DRM clients have exited.  In the
 * mode setting case, we want to restore the kernel's initial mode (just
 * in case the last client left us in a bad state).
 *
 * Additionally, in the non-mode setting case, we'll tear down the AGP
 * and DMA structures, since the kernel won't be using them, and clea
 * up any GEM state.
 */
1243
void i915_driver_lastclose(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
1244
{
1245
1246
	drm_i915_private_t *dev_priv = dev->dev_private;

1247
1248
	if (!dev_priv || drm_core_check_feature(dev, DRIVER_MODESET)) {
		intelfb_restore();
Dave Airlie's avatar
Dave Airlie committed
1249
		return;
1250
	}
Dave Airlie's avatar
Dave Airlie committed
1251

1252
1253
	i915_gem_lastclose(dev);

1254
	if (dev_priv->agp_heap)