i915_dma.c 35.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
44
{
	drm_i915_private_t *dev_priv = dev->dev_private;
	drm_i915_ring_buffer_t *ring = &(dev_priv->ring);
45
46
47
	u32 acthd_reg = IS_I965G(dev) ? ACTHD_I965 : ACTHD;
	u32 last_acthd = I915_READ(acthd_reg);
	u32 acthd;
48
	u32 last_head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
Linus Torvalds's avatar
Linus Torvalds committed
49
50
	int i;

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

60
61
62
63
64
65
		if (dev->primary->master) {
			struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
			if (master_priv->sarea_priv)
				master_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
		}

Linus Torvalds's avatar
Linus Torvalds committed
66
67
68

		if (ring->head != last_head)
			i = 0;
69
70
		if (acthd != last_acthd)
			i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
71
72

		last_head = ring->head;
73
74
75
		last_acthd = acthd;
		msleep_interruptible(10);

Linus Torvalds's avatar
Linus Torvalds committed
76
77
	}

Eric Anholt's avatar
Eric Anholt committed
78
	return -EBUSY;
Linus Torvalds's avatar
Linus Torvalds committed
79
80
}

81
82
83
84
/**
 * Sets up the hardware status page for devices that need a physical address
 * in the register.
 */
85
static int i915_init_phys_hws(struct drm_device *dev)
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
{
	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.
 */
110
static void i915_free_hws(struct drm_device *dev)
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
{
	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);
}

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

133
134
135
136
137
138
139
	/*
	 * 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;

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

146
147
148
149
150
151
	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
152
153
}

154
static int i915_dma_cleanup(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
155
{
156
	drm_i915_private_t *dev_priv = dev->dev_private;
Linus Torvalds's avatar
Linus Torvalds committed
157
158
159
160
	/* 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.
	 */
161
	if (dev->irq_enabled)
Dave Airlie's avatar
Dave Airlie committed
162
		drm_irq_uninstall(dev);
Linus Torvalds's avatar
Linus Torvalds committed
163

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

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

	return 0;
}

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

183
184
185
186
187
188
189
190
	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");
	}

191
192
193
194
195
196
197
	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
198

199
200
		dev_priv->ring.Size = init->ring_size;
		dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
Linus Torvalds's avatar
Linus Torvalds committed
201

202
203
204
205
206
		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
207

208
		drm_core_ioremap_wc(&dev_priv->ring.map, dev);
209
210
211
212
213
214
215

		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
216
217
218
219
	}

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

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

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

	return 0;
}

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

238
	DRM_DEBUG("%s\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
239
240
241
242

	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
243
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
244
245
246
247
248
	}

	/* 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
249
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
250
251
252
	}
	DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page);

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

	return 0;
}

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

268
	switch (init->func) {
Linus Torvalds's avatar
Linus Torvalds committed
269
	case I915_INIT_DMA:
270
		retcode = i915_initialize(dev, init);
Linus Torvalds's avatar
Linus Torvalds committed
271
272
273
274
275
		break;
	case I915_CLEANUP_DMA:
		retcode = i915_dma_cleanup(dev);
		break;
	case I915_RESUME_DMA:
Dave Airlie's avatar
Dave Airlie committed
276
		retcode = i915_dma_resume(dev);
Linus Torvalds's avatar
Linus Torvalds committed
277
278
		break;
	default:
Eric Anholt's avatar
Eric Anholt committed
279
		retcode = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
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
317
318
319
		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
320
			switch ((cmd >> 16) & 0xff) {
Linus Torvalds's avatar
Linus Torvalds committed
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
354
355
356
			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);

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

	return ret;
}

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

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

371
	BEGIN_LP_RING((dwords+1)&~1);
372

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

376
		cmd = buffer[i];
Linus Torvalds's avatar
Linus Torvalds committed
377
378

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

		OUT_RING(cmd);

		while (++i, --sz) {
384
			OUT_RING(buffer[i]);
Linus Torvalds's avatar
Linus Torvalds committed
385
386
387
		}
	}

388
389
390
391
392
	if (dwords & 1)
		OUT_RING(0);

	ADVANCE_LP_RING();

Linus Torvalds's avatar
Linus Torvalds committed
393
394
395
	return 0;
}

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

	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
408
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
409
410
	}

411
412
413
414
	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
415
		OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
416
417
418
419
420
421
422
423
424
425
426
427
		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
428
429
430
431

	return 0;
}

432
433
434
435
/* XXX: Emitting the counter should really be moved to part of the IRQ
 * emit. For now, do it in both places:
 */

436
static void i915_emit_breadcrumb(struct drm_device *dev)
437
438
{
	drm_i915_private_t *dev_priv = dev->dev_private;
439
	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
440
441
	RING_LOCALS;

442
	dev_priv->counter++;
443
	if (dev_priv->counter > 0x7FFFFFFFUL)
444
		dev_priv->counter = 0;
445
446
	if (master_priv->sarea_priv)
		master_priv->sarea_priv->last_enqueue = dev_priv->counter;
447
448

	BEGIN_LP_RING(4);
449
	OUT_RING(MI_STORE_DWORD_INDEX);
450
	OUT_RING(I915_BREADCRUMB_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
451
452
453
454
455
	OUT_RING(dev_priv->counter);
	OUT_RING(0);
	ADVANCE_LP_RING();
}

456
static int i915_dispatch_cmdbuffer(struct drm_device * dev,
457
458
459
				   drm_i915_cmdbuffer_t *cmd,
				   struct drm_clip_rect *cliprects,
				   void *cmdbuf)
Linus Torvalds's avatar
Linus Torvalds committed
460
461
462
463
464
465
{
	int nbox = cmd->num_cliprects;
	int i = 0, count, ret;

	if (cmd->sz & 0x3) {
		DRM_ERROR("alignment");
Eric Anholt's avatar
Eric Anholt committed
466
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
467
468
469
470
471
472
473
474
	}

	i915_kernel_lost_context(dev);

	count = nbox ? nbox : 1;

	for (i = 0; i < count; i++) {
		if (i < nbox) {
475
			ret = i915_emit_box(dev, cliprects, i,
Linus Torvalds's avatar
Linus Torvalds committed
476
477
478
479
480
					    cmd->DR1, cmd->DR4);
			if (ret)
				return ret;
		}

481
		ret = i915_emit_cmds(dev, cmdbuf, cmd->sz / 4);
Linus Torvalds's avatar
Linus Torvalds committed
482
483
484
485
		if (ret)
			return ret;
	}

486
	i915_emit_breadcrumb(dev);
Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
	return 0;
}

490
static int i915_dispatch_batchbuffer(struct drm_device * dev,
491
492
				     drm_i915_batchbuffer_t * batch,
				     struct drm_clip_rect *cliprects)
Linus Torvalds's avatar
Linus Torvalds committed
493
494
495
496
497
498
499
500
{
	drm_i915_private_t *dev_priv = dev->dev_private;
	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
501
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
502
503
504
505
506
507
508
509
	}

	i915_kernel_lost_context(dev);

	count = nbox ? nbox : 1;

	for (i = 0; i < count; i++) {
		if (i < nbox) {
510
			int ret = i915_emit_box(dev, cliprects, i,
Linus Torvalds's avatar
Linus Torvalds committed
511
512
513
514
515
						batch->DR1, batch->DR4);
			if (ret)
				return ret;
		}

516
		if (!IS_I830(dev) && !IS_845G(dev)) {
Linus Torvalds's avatar
Linus Torvalds committed
517
			BEGIN_LP_RING(2);
518
519
520
521
522
523
524
			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
525
526
527
528
529
530
531
532
533
534
535
			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();
		}
	}

536
	i915_emit_breadcrumb(dev);
Linus Torvalds's avatar
Linus Torvalds committed
537
538
539
540

	return 0;
}

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

548
	if (!master_priv->sarea_priv)
549
550
		return -EINVAL;

551
	DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n",
552
		  __func__,
553
		  dev_priv->current_page,
554
		  master_priv->sarea_priv->pf_current_page);
Linus Torvalds's avatar
Linus Torvalds committed
555

556
557
558
	i915_kernel_lost_context(dev);

	BEGIN_LP_RING(2);
559
	OUT_RING(MI_FLUSH | MI_READ_FLUSH);
560
561
	OUT_RING(0);
	ADVANCE_LP_RING();
Linus Torvalds's avatar
Linus Torvalds committed
562

563
564
565
566
567
568
	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
569
	} else {
570
571
		OUT_RING(dev_priv->front_offset);
		dev_priv->current_page = 0;
Linus Torvalds's avatar
Linus Torvalds committed
572
	}
573
574
	OUT_RING(0);
	ADVANCE_LP_RING();
Linus Torvalds's avatar
Linus Torvalds committed
575

576
577
578
579
	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
580

581
	master_priv->sarea_priv->last_enqueue = dev_priv->counter++;
Linus Torvalds's avatar
Linus Torvalds committed
582
583

	BEGIN_LP_RING(4);
584
	OUT_RING(MI_STORE_DWORD_INDEX);
585
	OUT_RING(I915_BREADCRUMB_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
586
587
	OUT_RING(dev_priv->counter);
	OUT_RING(0);
Linus Torvalds's avatar
Linus Torvalds committed
588
589
	ADVANCE_LP_RING();

590
	master_priv->sarea_priv->pf_current_page = dev_priv->current_page;
591
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
592
593
}

594
static int i915_quiescent(struct drm_device * dev)
Linus Torvalds's avatar
Linus Torvalds committed
595
596
597
598
{
	drm_i915_private_t *dev_priv = dev->dev_private;

	i915_kernel_lost_context(dev);
599
	return i915_wait_ring(dev, dev_priv->ring.Size - 8, __func__);
Linus Torvalds's avatar
Linus Torvalds committed
600
601
}

602
603
static int i915_flush_ioctl(struct drm_device *dev, void *data,
			    struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
604
{
605
606
607
	int ret;

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

609
610
611
612
613
	mutex_lock(&dev->struct_mutex);
	ret = i915_quiescent(dev);
	mutex_unlock(&dev->struct_mutex);

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
614
615
}

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

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

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

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

637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
	if (batch->num_cliprects < 0)
		return -EINVAL;

	if (batch->num_cliprects) {
		cliprects = drm_calloc(batch->num_cliprects,
				       sizeof(struct drm_clip_rect),
				       DRM_MEM_DRIVER);
		if (cliprects == NULL)
			return -ENOMEM;

		ret = copy_from_user(cliprects, batch->cliprects,
				     batch->num_cliprects *
				     sizeof(struct drm_clip_rect));
		if (ret != 0)
			goto fail_free;
	}
Linus Torvalds's avatar
Linus Torvalds committed
653

654
	mutex_lock(&dev->struct_mutex);
655
	ret = i915_dispatch_batchbuffer(dev, batch, cliprects);
656
	mutex_unlock(&dev->struct_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
657

658
	if (sarea_priv)
659
		sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
660
661
662
663
664
665

fail_free:
	drm_free(cliprects,
		 batch->num_cliprects * sizeof(struct drm_clip_rect),
		 DRM_MEM_DRIVER);

Linus Torvalds's avatar
Linus Torvalds committed
666
667
668
	return ret;
}

669
670
static int i915_cmdbuffer(struct drm_device *dev, void *data,
			  struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
671
672
{
	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
673
	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
Linus Torvalds's avatar
Linus Torvalds committed
674
	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
675
	    master_priv->sarea_priv;
676
	drm_i915_cmdbuffer_t *cmdbuf = data;
677
678
	struct drm_clip_rect *cliprects = NULL;
	void *batch_data;
Linus Torvalds's avatar
Linus Torvalds committed
679
680
681
	int ret;

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

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

686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
	if (cmdbuf->num_cliprects < 0)
		return -EINVAL;

	batch_data = drm_alloc(cmdbuf->sz, DRM_MEM_DRIVER);
	if (batch_data == NULL)
		return -ENOMEM;

	ret = copy_from_user(batch_data, cmdbuf->buf, cmdbuf->sz);
	if (ret != 0)
		goto fail_batch_free;

	if (cmdbuf->num_cliprects) {
		cliprects = drm_calloc(cmdbuf->num_cliprects,
				       sizeof(struct drm_clip_rect),
				       DRM_MEM_DRIVER);
		if (cliprects == NULL)
			goto fail_batch_free;

		ret = copy_from_user(cliprects, cmdbuf->cliprects,
				     cmdbuf->num_cliprects *
				     sizeof(struct drm_clip_rect));
		if (ret != 0)
			goto fail_clip_free;
Linus Torvalds's avatar
Linus Torvalds committed
709
710
	}

711
	mutex_lock(&dev->struct_mutex);
712
	ret = i915_dispatch_cmdbuffer(dev, cmdbuf, cliprects, batch_data);
713
	mutex_unlock(&dev->struct_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
714
715
	if (ret) {
		DRM_ERROR("i915_dispatch_cmdbuffer failed\n");
716
		goto fail_batch_free;
Linus Torvalds's avatar
Linus Torvalds committed
717
718
	}

719
	if (sarea_priv)
720
		sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
721
722
723
724
725
726
727
728
729

fail_batch_free:
	drm_free(batch_data, cmdbuf->sz, DRM_MEM_DRIVER);
fail_clip_free:
	drm_free(cliprects,
		 cmdbuf->num_cliprects * sizeof(struct drm_clip_rect),
		 DRM_MEM_DRIVER);

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
730
731
}

732
733
static int i915_flip_bufs(struct drm_device *dev, void *data,
			  struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
734
{
735
736
	int ret;

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

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

741
742
743
744
745
	mutex_lock(&dev->struct_mutex);
	ret = i915_dispatch_flip(dev);
	mutex_unlock(&dev->struct_mutex);

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
746
747
}

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

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

760
	switch (param->param) {
Linus Torvalds's avatar
Linus Torvalds committed
761
	case I915_PARAM_IRQ_ACTIVE:
762
		value = dev->pdev->irq ? 1 : 0;
Linus Torvalds's avatar
Linus Torvalds committed
763
764
765
766
		break;
	case I915_PARAM_ALLOW_BATCHBUFFER:
		value = dev_priv->allow_batchbuffer ? 1 : 0;
		break;
Dave Airlie's avatar
Dave Airlie committed
767
768
769
	case I915_PARAM_LAST_DISPATCH:
		value = READ_BREADCRUMB(dev_priv);
		break;
770
771
772
	case I915_PARAM_CHIPSET_ID:
		value = dev->pci_device;
		break;
773
	case I915_PARAM_HAS_GEM:
774
		value = dev_priv->has_gem;
775
		break;
776
777
778
	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
779
	default:
780
		DRM_DEBUG("Unknown parameter %d\n", param->param);
Eric Anholt's avatar
Eric Anholt committed
781
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
782
783
	}

784
	if (DRM_COPY_TO_USER(param->value, &value, sizeof(int))) {
Linus Torvalds's avatar
Linus Torvalds committed
785
		DRM_ERROR("DRM_COPY_TO_USER failed\n");
Eric Anholt's avatar
Eric Anholt committed
786
		return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
787
788
789
790
791
	}

	return 0;
}

792
793
static int i915_setparam(struct drm_device *dev, void *data,
			 struct drm_file *file_priv)
Linus Torvalds's avatar
Linus Torvalds committed
794
795
{
	drm_i915_private_t *dev_priv = dev->dev_private;
796
	drm_i915_setparam_t *param = data;
Linus Torvalds's avatar
Linus Torvalds committed
797
798

	if (!dev_priv) {
799
		DRM_ERROR("called with no initialization\n");
Eric Anholt's avatar
Eric Anholt committed
800
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
801
802
	}

803
	switch (param->param) {
Linus Torvalds's avatar
Linus Torvalds committed
804
805
806
	case I915_SETPARAM_USE_MI_BATCHBUFFER_START:
		break;
	case I915_SETPARAM_TEX_LRU_LOG_GRANULARITY:
807
		dev_priv->tex_lru_log_granularity = param->value;
Linus Torvalds's avatar
Linus Torvalds committed
808
809
		break;
	case I915_SETPARAM_ALLOW_BATCHBUFFER:
810
		dev_priv->allow_batchbuffer = param->value;
Linus Torvalds's avatar
Linus Torvalds committed
811
		break;
812
813
814
815
816
817
818
	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
819
	default:
820
		DRM_DEBUG("unknown parameter %d\n", param->param);
Eric Anholt's avatar
Eric Anholt committed
821
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
822
823
824
825
826
	}

	return 0;
}

827
828
static int i915_set_status_page(struct drm_device *dev, void *data,
				struct drm_file *file_priv)
829
830
{
	drm_i915_private_t *dev_priv = dev->dev_private;
831
	drm_i915_hws_addr_t *hws = data;
832
833
834

	if (!I915_NEED_GFX_HWS(dev))
		return -EINVAL;
835
836

	if (!dev_priv) {
837
		DRM_ERROR("called with no initialization\n");
Eric Anholt's avatar
Eric Anholt committed
838
		return -EINVAL;
839
840
	}

841
842
843
844
845
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		WARN(1, "tried to set status page when mode setting active\n");
		return 0;
	}

846
847
848
	printk(KERN_DEBUG "set status page addr 0x%08x\n", (u32)hws->addr);

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

850
	dev_priv->hws_map.offset = dev->agp->base + hws->addr;
851
852
853
854
855
	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;

856
	drm_core_ioremap_wc(&dev_priv->hws_map, dev);
857
858
859
860
861
	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
862
		return -ENOMEM;
863
864
865
866
	}
	dev_priv->hw_status_page = dev_priv->hws_map.handle;

	memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
867
868
	I915_WRITE(HWS_PGA, dev_priv->status_gfx_addr);
	DRM_DEBUG("load hws HWS_PGA with gfx mem 0x%x\n",
869
870
871
872
873
			dev_priv->status_gfx_addr);
	DRM_DEBUG("load hws at %p\n", dev_priv->hw_status_page);
	return 0;
}

874
875
876
877
878
879
880
881
882
883
/**
 * 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.
 */
884
885
static int i915_probe_agp(struct drm_device *dev, unsigned long *aperture_size,
			  unsigned long *preallocated_size)
886
887
888
889
{
	struct pci_dev *bridge_dev;
	u16 tmp = 0;
	unsigned long overhead;
890
	unsigned long stolen;
891
892
893
894
895
896
897
898
899
900
901
902
903
904

	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;

905
	switch (dev->pdev->device) {
906
907
908
909
910
911
912
913
914
915
916
	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 */
917
		*aperture_size = pci_resource_len(dev->pdev, 2);
918
919
920
921
922
923
924
		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.
	 */
925
	if (IS_G4X(dev) || IS_IGD(dev))
926
927
928
929
		overhead = 4096;
	else
		overhead = (*aperture_size / 1024) + 4096;

930
931
932
933
	switch (tmp & INTEL_GMCH_GMS_MASK) {
	case INTEL_855_GMCH_GMS_DISABLED:
		DRM_ERROR("video memory is disabled\n");
		return -1;
934
	case INTEL_855_GMCH_GMS_STOLEN_1M:
935
936
		stolen = 1 * 1024 * 1024;
		break;
937
	case INTEL_855_GMCH_GMS_STOLEN_4M:
938
		stolen = 4 * 1024 * 1024;
939
940
		break;
	case INTEL_855_GMCH_GMS_STOLEN_8M:
941
		stolen = 8 * 1024 * 1024;
942
943
		break;
	case INTEL_855_GMCH_GMS_STOLEN_16M:
944
		stolen = 16 * 1024 * 1024;
945
946
		break;
	case INTEL_855_GMCH_GMS_STOLEN_32M:
947
		stolen = 32 * 1024 * 1024;
948
949
		break;
	case INTEL_915G_GMCH_GMS_STOLEN_48M:
950
		stolen = 48 * 1024 * 1024;
951
952
		break;
	case INTEL_915G_GMCH_GMS_STOLEN_64M:
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
		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;
972
973
974
		break;
	default:
		DRM_ERROR("unexpected GMCH_GMS value: 0x%02x\n",
975
			tmp & INTEL_GMCH_GMS_MASK);
976
977
		return -1;
	}
978
	*preallocated_size = stolen - overhead;
979
980
981
982
983
984
985
986
987
988
989

	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;

990
991
992
993
994
995
	dev->devname = kstrdup(DRIVER_NAME, GFP_KERNEL);
	if (!dev->devname) {
		ret = -ENOMEM;
		goto out;
	}

996
997
998
	dev->mode_config.fb_base = drm_get_resource_start(dev, fb_bar) &
		0xff000000;

999
	if (IS_MOBILE(dev) || IS_I9XX(dev))
1000
1001
1002
1003
		dev_priv->cursor_needs_physical = true;
	else
		dev_priv->cursor_needs_physical = false;

1004
1005
1006
	if (IS_I965G(dev) || IS_G33(dev))
		dev_priv->cursor_needs_physical = false;

1007
1008
1009
	ret = i915_probe_agp(dev, &agp_size, &prealloc_size);
	if (ret)
		goto kfree_devname;
1010
1011
1012
1013
1014
1015
1016
1017
1018

	/* 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)
1019
		goto kfree_devname;
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044

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

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

1045
	drm_helper_initial_config(dev);
1046
1047
1048
1049
1050

	return 0;

destroy_ringbuffer:
	i915_gem_cleanup_ringbuffer(dev);
1051
1052
kfree_devname:
	kfree(dev->devname);
1053
1054
1055
1056
out:
	return ret;
}

1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
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;
}

1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
/**
 * 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
 */
1092
int i915_driver_load(struct drm_device *dev, unsigned long flags)
1093
{
1094
	struct drm_i915_private *dev_priv = dev->dev_private;
1095
	resource_size_t base, size;
1096
1097
	int ret = 0, mmio_bar = IS_I9XX(dev) ? 0 : 1;

1098
1099
1100
1101
1102
1103
1104
	/* 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;

1105
1106
1107
1108
1109
1110
1111
	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;
1112
	dev_priv->dev = dev;
1113
1114
1115
1116
1117

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

1118
	dev_priv->regs = ioremap(base, size);
1119
1120
1121
1122
1123
	if (!dev_priv->regs) {
		DRM_ERROR("failed to map registers\n");
		ret = -EIO;
		goto free_priv;
	}
1124

1125
1126
1127
        dev_priv->mm.gtt_mapping =
		io_mapping_create_wc(dev->agp->base,
				     dev->agp->agp_info.aper_size * 1024*1024);
1128
1129
1130
1131
1132
	if (dev_priv->mm.gtt_mapping == NULL) {
		ret = -EIO;
		goto out_rmmap;
	}

1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
	/* 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) {
1143
		DRM_INFO("MTRR allocation failed.  Graphics "
1144
1145
1146
			 "performance may suffer.\n");
	}

1147
1148
1149
1150
1151
1152
1153
1154
#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

1155
1156
1157
1158
	dev->driver->get_vblank_counter = i915_get_vblank_counter;
	if (IS_GM45(dev))
		dev->driver->get_vblank_counter = gm45_get_vblank_counter;

1159
1160
	i915_gem_load(dev);

1161
1162
1163
1164
	/* Init HWS */
	if (!I915_NEED_GFX_HWS(dev)) {
		ret = i915_init_phys_hws(dev);
		if (ret != 0)
1165
			goto out_iomapfree;
1166
	}
1167
1168
1169
1170
1171
1172
1173

	/* 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.
1174
1175
	 *
	 * According to chipset errata, on the 965GM, MSI interrupts may
1176
1177
	 * be lost or delayed, but we use them anyways to avoid
	 * stuck interrupts on some machines.
1178
	 */
1179
	if (!IS_I945G(dev) && !IS_I945GM(dev))
1180
		pci_enable_msi(dev->pdev);
1181
1182

	spin_lock_init(&dev_priv->user_irq_lock);
1183
	dev_priv->user_irq_refcount = 0;
1184

1185
1186
1187
1188
1189
1190
1191
	ret = drm_vblank_init(dev, I915_NUM_PIPE);

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

1192
1193
1194
1195
1196
1197
1198
1199
	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;
		}
	}

1200
1201
1202
	/* Must be done after probing outputs */
	intel_opregion_init(dev, 0);

1203
1204
	return 0;

1205
1206
out_iomapfree:
	io_mapping_free(dev_priv->mm.gtt_mapping);
1207
1208
1209
1210
out_rmmap:
	iounmap(dev_priv->regs);
free_priv:
	drm_free(dev_priv, sizeof(struct drm_i915_private), DRM_MEM_DRIVER);
1211
1212
1213
1214
1215
1216
1217
	return ret;
}

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

1218
1219
1220
1221
1222
1223
1224
	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;
	}

1225
1226
1227
1228
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		drm_irq_uninstall(dev);
	}

1229
1230
1231
	if (dev->pdev->msi_enabled)
		pci_disable_msi(dev->pdev);

1232
1233
	if (dev_priv->regs != NULL)
		iounmap(dev_priv->regs);