← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/mesa/drivers/dri/i915tex/server/intel_dri.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/drivers/dri/i915tex/server/intel_dri.c
 
1
/**
 
2
 * \file server/intel_dri.c
 
3
 * \brief File to perform the device-specific initialization tasks typically
 
4
 * done in the X server.
 
5
 *
 
6
 * Here they are converted to run in the client (or perhaps a standalone
 
7
 * process), and to work with the frame buffer device rather than the X
 
8
 * server infrastructure.
 
9
 * 
 
10
 * Copyright (C) 2006 Dave Airlie (airlied@linux.ie)
 
11
 
 
12
 Permission is hereby granted, free of charge, to any person obtaining a
 
13
 copy of this software and associated documentation files (the
 
14
 "Software"), to deal in the Software without restriction, including
 
15
 without limitation the rights to use, copy, modify, merge, publish,
 
16
 distribute, sub license, and/or sell copies of the Software, and to
 
17
 permit persons to whom the Software is furnished to do so, subject to
 
18
 the following conditions:
 
19
 
 
20
 The above copyright notice and this permission notice (including the
 
21
 next paragraph) shall be included in all copies or substantial portions
 
22
 of the Software.
 
23
 
 
24
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
25
 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
26
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 
27
 IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR
 
28
 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 
29
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 
30
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
31
*/
 
32
 
 
33
#include <stdio.h>
 
34
#include <stdlib.h>
 
35
#include <string.h>
 
36
#include <errno.h>
 
37
#include <unistd.h>
 
38
 
 
39
#include "driver.h"
 
40
#include "drm.h"
 
41
 
 
42
#include "intel.h"
 
43
#include "i830_dri.h"
 
44
 
 
45
#include "memops.h"
 
46
#include "pciaccess.h"
 
47
 
 
48
static size_t drm_page_size;
 
49
static int nextTile = 0;
 
50
#define xf86DrvMsg(...) do {} while(0)
 
51
 
 
52
static const int pitches[] = {
 
53
  128 * 8,
 
54
  128 * 16,
 
55
  128 * 32,
 
56
  128 * 64,
 
57
  0
 
58
};
 
59
 
 
60
static Bool I830DRIDoMappings(DRIDriverContext *ctx, I830Rec *pI830, drmI830Sarea *sarea);
 
61
 
 
62
static unsigned long
 
63
GetBestTileAlignment(unsigned long size)
 
64
{
 
65
   unsigned long i;
 
66
 
 
67
   for (i = KB(512); i < size; i <<= 1)
 
68
      ;
 
69
 
 
70
   if (i > MB(64))
 
71
      i = MB(64);
 
72
 
 
73
   return i;
 
74
}
 
75
 
 
76
static void SetFenceRegs(const DRIDriverContext *ctx, I830Rec *pI830)
 
77
{
 
78
  int i;
 
79
  unsigned char *MMIO = ctx->MMIOAddress;
 
80
 
 
81
  for (i = 0; i < 8; i++) {
 
82
    OUTREG(FENCE + i * 4, pI830->Fence[i]);
 
83
    //    if (I810_DEBUG & DEBUG_VERBOSE_VGA)
 
84
    fprintf(stderr,"Fence Register : %x\n", pI830->Fence[i]);
 
85
  }
 
86
}
 
87
 
 
88
/* Tiled memory is good... really, really good...
 
89
 *
 
90
 * Need to make it less likely that we miss out on this - probably
 
91
 * need to move the frontbuffer away from the 'guarenteed' alignment
 
92
 * of the first memory segment, or perhaps allocate a discontigous
 
93
 * framebuffer to get more alignment 'sweet spots'.
 
94
 */
 
95
static void
 
96
SetFence(const DRIDriverContext *ctx, I830Rec *pI830,
 
97
         int nr, unsigned int start, unsigned int pitch,
 
98
         unsigned int size)
 
99
{
 
100
   unsigned int val;
 
101
   unsigned int fence_mask = 0;
 
102
   unsigned int fence_pitch;
 
103
 
 
104
   if (nr < 0 || nr > 7) {
 
105
      fprintf(stderr,
 
106
                 "SetFence: fence %d out of range\n",nr);
 
107
      return;
 
108
   }
 
109
 
 
110
   pI830->Fence[nr] = 0;
 
111
 
 
112
   if (IS_I9XX(pI830))
 
113
        fence_mask = ~I915G_FENCE_START_MASK;
 
114
   else
 
115
        fence_mask = ~I830_FENCE_START_MASK;
 
116
 
 
117
   if (start & fence_mask) {
 
118
      fprintf(stderr,
 
119
                 "SetFence: %d: start (0x%08x) is not %s aligned\n",
 
120
                 nr, start, (IS_I9XX(pI830)) ? "1MB" : "512k");
 
121
      return;
 
122
   }
 
123
 
 
124
   if (start % size) {
 
125
      fprintf(stderr,
 
126
                 "SetFence: %d: start (0x%08x) is not size (%dk) aligned\n",
 
127
                 nr, start, size / 1024);
 
128
      return;
 
129
   }
 
130
 
 
131
   if (pitch & 127) {
 
132
      fprintf(stderr,
 
133
                 "SetFence: %d: pitch (%d) not a multiple of 128 bytes\n",
 
134
                 nr, pitch);
 
135
      return;
 
136
   }
 
137
 
 
138
   val = (start | FENCE_X_MAJOR | FENCE_VALID);
 
139
 
 
140
   if (IS_I9XX(pI830)) {
 
141
        switch (size) {
 
142
           case MB(1):
 
143
                val |= I915G_FENCE_SIZE_1M;
 
144
                break;
 
145
           case MB(2):
 
146
                val |= I915G_FENCE_SIZE_2M;
 
147
                break;
 
148
           case MB(4):
 
149
                val |= I915G_FENCE_SIZE_4M;
 
150
                break;
 
151
           case MB(8):
 
152
                val |= I915G_FENCE_SIZE_8M;
 
153
                break;
 
154
           case MB(16):
 
155
                val |= I915G_FENCE_SIZE_16M;
 
156
                break;
 
157
           case MB(32):
 
158
                val |= I915G_FENCE_SIZE_32M;
 
159
                break;
 
160
           case MB(64):
 
161
                val |= I915G_FENCE_SIZE_64M;
 
162
                break;
 
163
           default:
 
164
                fprintf(stderr,
 
165
                 "SetFence: %d: illegal size (%d kByte)\n", nr, size / 1024);
 
166
                return;
 
167
        }
 
168
    } else {
 
169
        switch (size) {
 
170
           case KB(512):
 
171
                val |= FENCE_SIZE_512K;
 
172
                break;
 
173
           case MB(1):
 
174
                val |= FENCE_SIZE_1M;
 
175
                break;
 
176
           case MB(2):
 
177
                val |= FENCE_SIZE_2M;
 
178
                break;
 
179
           case MB(4):
 
180
                val |= FENCE_SIZE_4M;
 
181
                break;
 
182
           case MB(8):
 
183
                val |= FENCE_SIZE_8M;
 
184
                break;
 
185
           case MB(16):
 
186
                val |= FENCE_SIZE_16M;
 
187
                break;
 
188
           case MB(32):
 
189
                val |= FENCE_SIZE_32M;
 
190
                break;
 
191
           case MB(64):
 
192
                val |= FENCE_SIZE_64M;
 
193
                break;
 
194
           default:
 
195
                fprintf(stderr,
 
196
                 "SetFence: %d: illegal size (%d kByte)\n", nr, size / 1024);
 
197
                return;
 
198
        }
 
199
   }
 
200
 
 
201
   if (IS_I9XX(pI830))
 
202
        fence_pitch = pitch / 512;
 
203
   else
 
204
        fence_pitch = pitch / 128;
 
205
 
 
206
   switch (fence_pitch) {
 
207
   case 1:
 
208
      val |= FENCE_PITCH_1;
 
209
      break;
 
210
   case 2:
 
211
      val |= FENCE_PITCH_2;
 
212
      break;
 
213
   case 4:
 
214
      val |= FENCE_PITCH_4;
 
215
      break;
 
216
   case 8:
 
217
      val |= FENCE_PITCH_8;
 
218
      break;
 
219
   case 16:
 
220
      val |= FENCE_PITCH_16;
 
221
      break;
 
222
   case 32:
 
223
      val |= FENCE_PITCH_32;
 
224
      break;
 
225
   case 64:
 
226
      val |= FENCE_PITCH_64;
 
227
      break;
 
228
   default:
 
229
      fprintf(stderr,
 
230
                 "SetFence: %d: illegal pitch (%d)\n", nr, pitch);
 
231
      return;
 
232
   }
 
233
 
 
234
   pI830->Fence[nr] = val;
 
235
}
 
236
 
 
237
static Bool
 
238
MakeTiles(const DRIDriverContext *ctx, I830Rec *pI830, I830MemRange *pMem)
 
239
{
 
240
   int pitch, ntiles, i;
 
241
 
 
242
   pitch = pMem->Pitch * ctx->cpp;
 
243
   /*
 
244
    * Simply try to break the region up into at most four pieces of size
 
245
    * equal to the alignment.
 
246
    */
 
247
   ntiles = ROUND_TO(pMem->Size, pMem->Alignment) / pMem->Alignment;
 
248
   if (ntiles >= 4) {
 
249
      return FALSE;
 
250
   }
 
251
 
 
252
   for (i = 0; i < ntiles; i++, nextTile++) {
 
253
     SetFence(ctx, pI830, nextTile, pMem->Start + i * pMem->Alignment,
 
254
               pitch, pMem->Alignment);
 
255
   }
 
256
   return TRUE;
 
257
}
 
258
 
 
259
static void I830SetupMemoryTiling(const DRIDriverContext *ctx, I830Rec *pI830)
 
260
{
 
261
  int i;
 
262
 
 
263
  /* Clear out */
 
264
  for (i = 0; i < 8; i++)
 
265
    pI830->Fence[i] = 0;
 
266
  
 
267
  nextTile = 0;
 
268
 
 
269
  if (pI830->BackBuffer.Alignment >= KB(512)) {
 
270
    if (MakeTiles(ctx, pI830, &(pI830->BackBuffer))) {
 
271
      fprintf(stderr,
 
272
                 "Activating tiled memory for the back buffer.\n");
 
273
    } else {
 
274
      fprintf(stderr,
 
275
                 "MakeTiles failed for the back buffer.\n");
 
276
      pI830->allowPageFlip = FALSE;
 
277
    }
 
278
  }
 
279
  
 
280
  if (pI830->DepthBuffer.Alignment >= KB(512)) {
 
281
    if (MakeTiles(ctx, pI830, &(pI830->DepthBuffer))) {
 
282
      fprintf(stderr,
 
283
                 "Activating tiled memory for the depth buffer.\n");
 
284
    } else {
 
285
      fprintf(stderr,
 
286
                 "MakeTiles failed for the depth buffer.\n");
 
287
    }
 
288
  }
 
289
 
 
290
  return;
 
291
}
 
292
 
 
293
static int I830DetectMemory(const DRIDriverContext *ctx, I830Rec *pI830)
 
294
{
 
295
  struct pci_device host_bridge, ig_dev;
 
296
  uint32_t gmch_ctrl;
 
297
  int memsize = 0;
 
298
  int range;
 
299
  uint32_t aper_size;
 
300
  uint32_t membase2 = 0;
 
301
      
 
302
  memset(&host_bridge, 0, sizeof(host_bridge));
 
303
  memset(&ig_dev, 0, sizeof(ig_dev));
 
304
 
 
305
  ig_dev.dev = 2;
 
306
 
 
307
  pci_device_cfg_read_u32(&host_bridge, &gmch_ctrl, I830_GMCH_CTRL);
 
308
 
 
309
  if (IS_I830(pI830) || IS_845G(pI830)) {
 
310
    if ((gmch_ctrl & I830_GMCH_MEM_MASK) == I830_GMCH_MEM_128M) {
 
311
      aper_size = 0x80000000;
 
312
    } else {
 
313
      aper_size = 0x40000000;
 
314
    }
 
315
  } else {
 
316
    if (IS_I9XX(pI830)) {
 
317
      int ret;
 
318
      ret = pci_device_cfg_read_u32(&ig_dev, &membase2, 0x18);
 
319
      if (membase2 & 0x08000000)
 
320
        aper_size = 0x8000000;
 
321
      else
 
322
        aper_size = 0x10000000;
 
323
 
 
324
      fprintf(stderr,"aper size is %08X %08x %d\n", aper_size, membase2, ret);
 
325
    } else
 
326
      aper_size = 0x8000000;
 
327
  }
 
328
 
 
329
  pI830->aper_size = aper_size;
 
330
 
 
331
 
 
332
  /* We need to reduce the stolen size, by the GTT and the popup.
 
333
   * The GTT varying according the the FbMapSize and the popup is 4KB */
 
334
  range = (ctx->shared.fbSize / (1024*1024)) + 4;
 
335
 
 
336
   if (IS_I85X(pI830) || IS_I865G(pI830) || IS_I9XX(pI830)) {
 
337
      switch (gmch_ctrl & I830_GMCH_GMS_MASK) {
 
338
      case I855_GMCH_GMS_STOLEN_1M:
 
339
         memsize = MB(1) - KB(range);
 
340
         break;
 
341
      case I855_GMCH_GMS_STOLEN_4M:
 
342
         memsize = MB(4) - KB(range);
 
343
         break;
 
344
      case I855_GMCH_GMS_STOLEN_8M:
 
345
         memsize = MB(8) - KB(range);
 
346
         break;
 
347
      case I855_GMCH_GMS_STOLEN_16M:
 
348
         memsize = MB(16) - KB(range);
 
349
         break;
 
350
      case I855_GMCH_GMS_STOLEN_32M:
 
351
         memsize = MB(32) - KB(range);
 
352
         break;
 
353
      case I915G_GMCH_GMS_STOLEN_48M:
 
354
         if (IS_I9XX(pI830))
 
355
            memsize = MB(48) - KB(range);
 
356
         break;
 
357
      case I915G_GMCH_GMS_STOLEN_64M:
 
358
         if (IS_I9XX(pI830))
 
359
            memsize = MB(64) - KB(range);
 
360
         break;
 
361
      }
 
362
   } else {
 
363
      switch (gmch_ctrl & I830_GMCH_GMS_MASK) {
 
364
      case I830_GMCH_GMS_STOLEN_512:
 
365
         memsize = KB(512) - KB(range);
 
366
         break;
 
367
      case I830_GMCH_GMS_STOLEN_1024:
 
368
         memsize = MB(1) - KB(range);
 
369
         break;
 
370
      case I830_GMCH_GMS_STOLEN_8192:
 
371
         memsize = MB(8) - KB(range);
 
372
         break;
 
373
      case I830_GMCH_GMS_LOCAL:
 
374
         memsize = 0;
 
375
         xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 
376
                    "Local memory found, but won't be used.\n");
 
377
         break;
 
378
      }
 
379
   }
 
380
   if (memsize > 0) {
 
381
     fprintf(stderr,
 
382
                 "detected %d kB stolen memory.\n", memsize / 1024);
 
383
   } else {
 
384
     fprintf(stderr,
 
385
                 "no video memory detected.\n");
 
386
   }
 
387
   return memsize;
 
388
}
 
389
 
 
390
static int AgpInit(const DRIDriverContext *ctx, I830Rec *info)
 
391
{
 
392
  unsigned long mode = 0x4;
 
393
 
 
394
  if (drmAgpAcquire(ctx->drmFD) < 0) {
 
395
    fprintf(stderr, "[gart] AGP not available\n");
 
396
    return 0;
 
397
  }
 
398
  
 
399
  if (drmAgpEnable(ctx->drmFD, mode) < 0) {
 
400
    fprintf(stderr, "[gart] AGP not enabled\n");
 
401
    drmAgpRelease(ctx->drmFD);
 
402
    return 0;
 
403
  }
 
404
  else
 
405
    fprintf(stderr, "[gart] AGP enabled at %dx\n", ctx->agpmode);
 
406
 
 
407
  return 1;
 
408
}
 
409
 
 
410
/*
 
411
 * Allocate memory from the given pool.  Grow the pool if needed and if
 
412
 * possible.
 
413
 */
 
414
static unsigned long
 
415
AllocFromPool(const DRIDriverContext *ctx, I830Rec *pI830, 
 
416
              I830MemRange *result, I830MemPool *pool,
 
417
              long size, unsigned long alignment, int flags)
 
418
{
 
419
   long needed, start, end;
 
420
 
 
421
   if (!result || !pool || !size)
 
422
      return 0;
 
423
 
 
424
   /* Calculate how much space is needed. */
 
425
   if (alignment <= GTT_PAGE_SIZE)
 
426
      needed = size;
 
427
   else {
 
428
         start = ROUND_TO(pool->Free.Start, alignment);
 
429
         end = ROUND_TO(start + size, alignment);
 
430
         needed = end - pool->Free.Start;
 
431
   }
 
432
   if (needed > pool->Free.Size) {
 
433
     return 0;
 
434
   }
 
435
 
 
436
   result->Start = ROUND_TO(pool->Free.Start, alignment);
 
437
   pool->Free.Start += needed;
 
438
   result->End = pool->Free.Start;
 
439
 
 
440
   pool->Free.Size = pool->Free.End - pool->Free.Start;
 
441
   result->Size = result->End - result->Start;
 
442
   result->Pool = pool;
 
443
   result->Alignment = alignment;
 
444
   return needed;
 
445
}
 
446
 
 
447
static unsigned long AllocFromAGP(const DRIDriverContext *ctx, I830Rec *pI830, long size, unsigned long alignment, I830MemRange  *result)
 
448
{
 
449
   unsigned long start, end;
 
450
   unsigned long newApStart, newApEnd;
 
451
   int ret;
 
452
   if (!result || !size)
 
453
      return 0;
 
454
   
 
455
   if (!alignment)
 
456
     alignment = 4;
 
457
 
 
458
   start = ROUND_TO(pI830->MemoryAperture.Start, alignment);
 
459
   end = ROUND_TO(start + size, alignment);
 
460
   newApStart = end;
 
461
   newApEnd = pI830->MemoryAperture.End;
 
462
 
 
463
   ret=drmAgpAlloc(ctx->drmFD, size, 0, &(result->Physical), (drm_handle_t *)&(result->Key));
 
464
   
 
465
   if (ret)
 
466
   {
 
467
     fprintf(stderr,"drmAgpAlloc failed %d\n", ret);
 
468
     return 0;
 
469
   }
 
470
   pI830->allocatedMemory += size;
 
471
   pI830->MemoryAperture.Start = newApStart;
 
472
   pI830->MemoryAperture.End = newApEnd;
 
473
   pI830->MemoryAperture.Size = newApEnd - newApStart;
 
474
   //   pI830->FreeMemory -= size;
 
475
   result->Start = start;
 
476
   result->End = start + size;
 
477
   result->Size = size;
 
478
   result->Offset = start;
 
479
   result->Alignment = alignment;
 
480
   result->Pool = NULL;
 
481
  
 
482
   return size;
 
483
}
 
484
 
 
485
unsigned long
 
486
I830AllocVidMem(const DRIDriverContext *ctx, I830Rec *pI830, I830MemRange *result, I830MemPool *pool, long size, unsigned long alignment, int flags)
 
487
{
 
488
  int ret;
 
489
 
 
490
  if (!result)
 
491
    return 0;
 
492
 
 
493
   /* Make sure these are initialised. */
 
494
   result->Size = 0;
 
495
   result->Key = -1;
 
496
 
 
497
   if (!size) {
 
498
      return 0;
 
499
   }
 
500
 
 
501
   if (pool->Free.Size < size)
 
502
     return AllocFromAGP(ctx, pI830, size, alignment, result);
 
503
   else
 
504
   {
 
505
     ret = AllocFromPool(ctx, pI830, result, pool, size, alignment, flags);
 
506
 
 
507
     if (ret==0)
 
508
       return AllocFromAGP(ctx, pI830, size, alignment, result);
 
509
     return ret;
 
510
   }
 
511
}
 
512
 
 
513
static Bool BindAgpRange(const DRIDriverContext *ctx, I830MemRange *mem)
 
514
{
 
515
  if (!mem)
 
516
    return FALSE;
 
517
  
 
518
  if (mem->Key == -1)
 
519
    return TRUE;
 
520
 
 
521
  return !drmAgpBind(ctx->drmFD, mem->Key, mem->Offset);
 
522
}
 
523
 
 
524
/* simple memory allocation routines needed */
 
525
/* put ring buffer in low memory */
 
526
/* need to allocate front, back, depth buffers aligned correctly,
 
527
   allocate ring buffer, 
 
528
*/
 
529
 
 
530
/* */
 
531
static Bool
 
532
I830AllocateMemory(const DRIDriverContext *ctx, I830Rec *pI830)
 
533
{
 
534
  unsigned long size, ret;
 
535
  unsigned long lines, lineSize, align;
 
536
 
 
537
  /* allocate ring buffer */
 
538
  memset(pI830->LpRing, 0, sizeof(I830RingBuffer));
 
539
  pI830->LpRing->mem.Key = -1;
 
540
 
 
541
  size = PRIMARY_RINGBUFFER_SIZE;
 
542
  
 
543
  ret = I830AllocVidMem(ctx, pI830, &pI830->LpRing->mem, &pI830->StolenPool, size, 0x1000, 0);
 
544
  
 
545
  if (ret != size)
 
546
  {
 
547
    fprintf(stderr,"unable to allocate ring buffer %ld\n", ret);
 
548
    return FALSE;
 
549
  }
 
550
 
 
551
  pI830->LpRing->tail_mask = pI830->LpRing->mem.Size - 1;
 
552
 
 
553
  
 
554
  /* allocate front buffer */
 
555
  memset(&(pI830->FrontBuffer), 0, sizeof(pI830->FrontBuffer));
 
556
  pI830->FrontBuffer.Key = -1;
 
557
  pI830->FrontBuffer.Pitch = ctx->shared.virtualWidth;
 
558
 
 
559
  align = KB(512);  
 
560
 
 
561
  lineSize = ctx->shared.virtualWidth * ctx->cpp;
 
562
  lines = (ctx->shared.virtualHeight + 15) / 16 * 16;
 
563
  size = lineSize * lines;
 
564
  size = ROUND_TO_PAGE(size);
 
565
 
 
566
  align = GetBestTileAlignment(size);
 
567
 
 
568
  ret = I830AllocVidMem(ctx, pI830, &pI830->FrontBuffer, &pI830->StolenPool, size, align, 0);
 
569
  if (ret < size)
 
570
  {
 
571
    fprintf(stderr,"unable to allocate front buffer %ld\n", ret);
 
572
    return FALSE;
 
573
  }
 
574
 
 
575
  memset(&(pI830->BackBuffer), 0, sizeof(pI830->BackBuffer));
 
576
  pI830->BackBuffer.Key = -1;
 
577
  pI830->BackBuffer.Pitch = ctx->shared.virtualWidth;
 
578
 
 
579
  ret = I830AllocVidMem(ctx, pI830, &pI830->BackBuffer, &pI830->StolenPool, size, align, 0);
 
580
  if (ret < size)
 
581
  {
 
582
    fprintf(stderr,"unable to allocate back buffer %ld\n", ret);
 
583
    return FALSE;
 
584
  }
 
585
  
 
586
  memset(&(pI830->DepthBuffer), 0, sizeof(pI830->DepthBuffer));
 
587
  pI830->DepthBuffer.Key = -1;
 
588
  pI830->DepthBuffer.Pitch = ctx->shared.virtualWidth;
 
589
 
 
590
  ret = I830AllocVidMem(ctx, pI830, &pI830->DepthBuffer, &pI830->StolenPool, size, align, 0);
 
591
  if (ret < size)
 
592
  {
 
593
    fprintf(stderr,"unable to allocate depth buffer %ld\n", ret);
 
594
    return FALSE;
 
595
  }
 
596
 
 
597
  memset(&(pI830->ContextMem), 0, sizeof(pI830->ContextMem));
 
598
  pI830->ContextMem.Key = -1;
 
599
  size = KB(32);
 
600
 
 
601
  ret = I830AllocVidMem(ctx, pI830, &pI830->ContextMem, &pI830->StolenPool, size, align, 0);
 
602
  if (ret < size)
 
603
  {
 
604
    fprintf(stderr,"unable to allocate context buffer %ld\n", ret);
 
605
    return FALSE;
 
606
  }
 
607
 
 
608
#if 0  
 
609
  memset(&(pI830->TexMem), 0, sizeof(pI830->TexMem));
 
610
  pI830->TexMem.Key = -1;
 
611
 
 
612
  size = 32768 * 1024;
 
613
  ret = AllocFromAGP(ctx, pI830, size, align, &pI830->TexMem);
 
614
  if (ret < size)
 
615
  {
 
616
    fprintf(stderr,"unable to allocate texture memory %ld\n", ret);
 
617
    return FALSE;
 
618
  }
 
619
#endif
 
620
 
 
621
  return TRUE;
 
622
}
 
623
 
 
624
static Bool
 
625
I830BindMemory(const DRIDriverContext *ctx, I830Rec *pI830)
 
626
{
 
627
  if (!BindAgpRange(ctx, &pI830->LpRing->mem))
 
628
    return FALSE;
 
629
  if (!BindAgpRange(ctx, &pI830->FrontBuffer))
 
630
    return FALSE;
 
631
  if (!BindAgpRange(ctx, &pI830->BackBuffer))
 
632
    return FALSE;
 
633
  if (!BindAgpRange(ctx, &pI830->DepthBuffer))
 
634
    return FALSE;
 
635
  if (!BindAgpRange(ctx, &pI830->ContextMem))
 
636
    return FALSE;
 
637
#if 0
 
638
  if (!BindAgpRange(ctx, &pI830->TexMem))
 
639
    return FALSE;
 
640
#endif
 
641
  return TRUE;
 
642
}
 
643
 
 
644
static void SetupDRIMM(const DRIDriverContext *ctx, I830Rec *pI830)
 
645
{
 
646
  unsigned long aperEnd = ROUND_DOWN_TO(pI830->aper_size, GTT_PAGE_SIZE) / GTT_PAGE_SIZE;
 
647
  unsigned long aperStart = ROUND_TO(pI830->aper_size - KB(32768), GTT_PAGE_SIZE) / GTT_PAGE_SIZE;
 
648
 
 
649
  fprintf(stderr, "aper size is %08X\n", ctx->shared.fbSize);
 
650
  if (drmMMInit(ctx->drmFD, aperStart, aperEnd - aperStart, DRM_BO_MEM_TT)) {
 
651
      fprintf(stderr,
 
652
              "DRM MM Initialization Failed\n");
 
653
  } else {
 
654
    fprintf(stderr,
 
655
            "DRM MM Initialized at offset 0x%lx length %d page\n", aperStart, aperEnd-aperStart);
 
656
  }
 
657
 
 
658
}
 
659
 
 
660
static Bool
 
661
I830CleanupDma(const DRIDriverContext *ctx)
 
662
{
 
663
   drmI830Init info;
 
664
 
 
665
   memset(&info, 0, sizeof(drmI830Init));
 
666
   info.func = I830_CLEANUP_DMA;
 
667
 
 
668
   if (drmCommandWrite(ctx->drmFD, DRM_I830_INIT,
 
669
                       &info, sizeof(drmI830Init))) {
 
670
     fprintf(stderr, "I830 Dma Cleanup Failed\n");
 
671
      return FALSE;
 
672
   }
 
673
 
 
674
   return TRUE;
 
675
}
 
676
 
 
677
static Bool
 
678
I830InitDma(const DRIDriverContext *ctx, I830Rec *pI830)
 
679
{
 
680
   I830RingBuffer *ring = pI830->LpRing;
 
681
   drmI830Init info;
 
682
 
 
683
   memset(&info, 0, sizeof(drmI830Init));
 
684
   info.func = I830_INIT_DMA;
 
685
 
 
686
   info.ring_start = ring->mem.Start + pI830->LinearAddr;
 
687
   info.ring_end = ring->mem.End + pI830->LinearAddr;
 
688
   info.ring_size = ring->mem.Size;
 
689
 
 
690
   info.mmio_offset = (unsigned int)ctx->MMIOStart;
 
691
 
 
692
   info.sarea_priv_offset = sizeof(drm_sarea_t);
 
693
 
 
694
   info.front_offset = pI830->FrontBuffer.Start;
 
695
   info.back_offset = pI830->BackBuffer.Start;
 
696
   info.depth_offset = pI830->DepthBuffer.Start;
 
697
   info.w = ctx->shared.virtualWidth;
 
698
   info.h = ctx->shared.virtualHeight;
 
699
   info.pitch = ctx->shared.virtualWidth;
 
700
   info.back_pitch = pI830->BackBuffer.Pitch;
 
701
   info.depth_pitch = pI830->DepthBuffer.Pitch;
 
702
   info.cpp = ctx->cpp;
 
703
 
 
704
   if (drmCommandWrite(ctx->drmFD, DRM_I830_INIT,
 
705
                       &info, sizeof(drmI830Init))) {
 
706
      fprintf(stderr,
 
707
                 "I830 Dma Initialization Failed\n");
 
708
      return FALSE;
 
709
   }
 
710
 
 
711
   return TRUE;
 
712
}
 
713
 
 
714
static int I830CheckDRMVersion( const DRIDriverContext *ctx,
 
715
                                  I830Rec *pI830 )
 
716
{
 
717
   drmVersionPtr  version;
 
718
 
 
719
   version = drmGetVersion(ctx->drmFD);
 
720
 
 
721
   if (version) {
 
722
     int req_minor, req_patch;
 
723
 
 
724
     req_minor = 4;
 
725
     req_patch = 0;     
 
726
 
 
727
     if (version->version_major != 1 ||
 
728
         version->version_minor < req_minor ||
 
729
         (version->version_minor == req_minor && 
 
730
          version->version_patchlevel < req_patch)) {
 
731
       /* Incompatible drm version */
 
732
       fprintf(stderr,
 
733
               "[dri] I830DRIScreenInit failed because of a version "
 
734
               "mismatch.\n"
 
735
               "[dri] i915.o kernel module version is %d.%d.%d "
 
736
               "but version 1.%d.%d or newer is needed.\n"
 
737
               "[dri] Disabling DRI.\n",
 
738
               version->version_major,
 
739
               version->version_minor,
 
740
               version->version_patchlevel,
 
741
               req_minor,
 
742
               req_patch);
 
743
       drmFreeVersion(version);
 
744
       return 0;
 
745
     }
 
746
     
 
747
     pI830->drmMinor = version->version_minor;
 
748
     drmFreeVersion(version);
 
749
   }
 
750
   return 1;
 
751
}
 
752
 
 
753
static void
 
754
I830SetRingRegs(const DRIDriverContext *ctx, I830Rec *pI830)
 
755
{
 
756
  unsigned int itemp;
 
757
  unsigned char *MMIO = ctx->MMIOAddress;
 
758
 
 
759
   OUTREG(LP_RING + RING_LEN, 0);
 
760
   OUTREG(LP_RING + RING_TAIL, 0);
 
761
   OUTREG(LP_RING + RING_HEAD, 0);
 
762
 
 
763
   if ((long)(pI830->LpRing->mem.Start & I830_RING_START_MASK) !=
 
764
       pI830->LpRing->mem.Start) {
 
765
      fprintf(stderr,
 
766
                 "I830SetRingRegs: Ring buffer start (%lx) violates its "
 
767
                 "mask (%x)\n", pI830->LpRing->mem.Start, I830_RING_START_MASK);
 
768
   }
 
769
   /* Don't care about the old value.  Reserved bits must be zero anyway. */
 
770
   itemp = pI830->LpRing->mem.Start & I830_RING_START_MASK;
 
771
   OUTREG(LP_RING + RING_START, itemp);
 
772
 
 
773
   if (((pI830->LpRing->mem.Size - 4096) & I830_RING_NR_PAGES) !=
 
774
       pI830->LpRing->mem.Size - 4096) {
 
775
      fprintf(stderr,
 
776
                 "I830SetRingRegs: Ring buffer size - 4096 (%lx) violates its "
 
777
                 "mask (%x)\n", pI830->LpRing->mem.Size - 4096,
 
778
                 I830_RING_NR_PAGES);
 
779
   }
 
780
   /* Don't care about the old value.  Reserved bits must be zero anyway. */
 
781
   itemp = (pI830->LpRing->mem.Size - 4096) & I830_RING_NR_PAGES;
 
782
   itemp |= (RING_NO_REPORT | RING_VALID);
 
783
   OUTREG(LP_RING + RING_LEN, itemp);
 
784
 
 
785
   pI830->LpRing->head = INREG(LP_RING + RING_HEAD) & I830_HEAD_MASK;
 
786
   pI830->LpRing->tail = INREG(LP_RING + RING_TAIL);
 
787
   pI830->LpRing->space = pI830->LpRing->head - (pI830->LpRing->tail + 8);
 
788
   if (pI830->LpRing->space < 0)
 
789
      pI830->LpRing->space += pI830->LpRing->mem.Size;
 
790
 
 
791
   SetFenceRegs(ctx, pI830);
 
792
   
 
793
   /* RESET THE DISPLAY PIPE TO POINT TO THE FRONTBUFFER - hacky
 
794
      hacky hacky */
 
795
   OUTREG(DSPABASE, pI830->FrontBuffer.Start + pI830->LinearAddr);
 
796
 
 
797
}
 
798
 
 
799
static Bool
 
800
I830SetParam(const DRIDriverContext *ctx, int param, int value)
 
801
{
 
802
   drmI830SetParam sp;
 
803
 
 
804
   memset(&sp, 0, sizeof(sp));
 
805
   sp.param = param;
 
806
   sp.value = value;
 
807
 
 
808
   if (drmCommandWrite(ctx->drmFD, DRM_I830_SETPARAM, &sp, sizeof(sp))) {
 
809
      fprintf(stderr, "I830 SetParam Failed\n");
 
810
      return FALSE;
 
811
   }
 
812
 
 
813
   return TRUE;
 
814
}
 
815
 
 
816
static Bool
 
817
I830DRIMapScreenRegions(DRIDriverContext *ctx, I830Rec *pI830, drmI830Sarea *sarea)
 
818
{
 
819
   fprintf(stderr,
 
820
              "[drm] Mapping front buffer\n");
 
821
 
 
822
   if (drmAddMap(ctx->drmFD,
 
823
                 (drm_handle_t)(sarea->front_offset + pI830->LinearAddr),
 
824
                 sarea->front_size,
 
825
                 DRM_FRAME_BUFFER,  /*DRM_AGP,*/
 
826
                 0,
 
827
                 &sarea->front_handle) < 0) {
 
828
     fprintf(stderr,
 
829
             "[drm] drmAddMap(front_handle) failed. Disabling DRI\n");
 
830
      return FALSE;
 
831
   }
 
832
   ctx->shared.hFrameBuffer = sarea->front_handle;
 
833
   ctx->shared.fbSize = sarea->front_size;
 
834
   fprintf(stderr, "[drm] Front Buffer = 0x%08x\n",
 
835
           sarea->front_handle);
 
836
 
 
837
   if (drmAddMap(ctx->drmFD,
 
838
                 (drm_handle_t)(sarea->back_offset),
 
839
                 sarea->back_size, DRM_AGP, 0,
 
840
                 &sarea->back_handle) < 0) {
 
841
      fprintf(stderr,
 
842
                 "[drm] drmAddMap(back_handle) failed. Disabling DRI\n");
 
843
      return FALSE;
 
844
   }
 
845
   fprintf(stderr, "[drm] Back Buffer = 0x%08x\n",
 
846
              sarea->back_handle);
 
847
 
 
848
   if (drmAddMap(ctx->drmFD,
 
849
                 (drm_handle_t)sarea->depth_offset,
 
850
                 sarea->depth_size, DRM_AGP, 0,
 
851
                 &sarea->depth_handle) < 0) {
 
852
      fprintf(stderr,
 
853
                 "[drm] drmAddMap(depth_handle) failed. Disabling DRI\n");
 
854
      return FALSE;
 
855
   }
 
856
   fprintf(stderr, "[drm] Depth Buffer = 0x%08x\n",
 
857
              sarea->depth_handle);
 
858
 
 
859
#if 0
 
860
   if (drmAddMap(ctx->drmFD,
 
861
                 (drm_handle_t)sarea->tex_offset,
 
862
                 sarea->tex_size, DRM_AGP, 0,
 
863
                 &sarea->tex_handle) < 0) {
 
864
      fprintf(stderr,
 
865
                 "[drm] drmAddMap(tex_handle) failed. Disabling DRI\n");
 
866
      return FALSE;
 
867
   }
 
868
   fprintf(stderr, "[drm] textures = 0x%08x\n",
 
869
              sarea->tex_handle);
 
870
#endif
 
871
   return TRUE;
 
872
}
 
873
 
 
874
 
 
875
static void
 
876
I830DRIUnmapScreenRegions(const DRIDriverContext *ctx, I830Rec *pI830, drmI830Sarea *sarea)
 
877
{
 
878
#if 1
 
879
   if (sarea->front_handle) {
 
880
      drmRmMap(ctx->drmFD, sarea->front_handle);
 
881
      sarea->front_handle = 0;
 
882
   }
 
883
#endif
 
884
   if (sarea->back_handle) {
 
885
      drmRmMap(ctx->drmFD, sarea->back_handle);
 
886
      sarea->back_handle = 0;
 
887
   }
 
888
   if (sarea->depth_handle) {
 
889
      drmRmMap(ctx->drmFD, sarea->depth_handle);
 
890
      sarea->depth_handle = 0;
 
891
   }
 
892
   if (sarea->tex_handle) {
 
893
      drmRmMap(ctx->drmFD, sarea->tex_handle);
 
894
      sarea->tex_handle = 0;
 
895
   }
 
896
}
 
897
 
 
898
#if 0
 
899
static void
 
900
I830InitTextureHeap(const DRIDriverContext *ctx, I830Rec *pI830, drmI830Sarea *sarea)
 
901
{
 
902
   /* Start up the simple memory manager for agp space */
 
903
   drmI830MemInitHeap drmHeap;
 
904
   drmHeap.region = I830_MEM_REGION_AGP;
 
905
   drmHeap.start  = 0;
 
906
   drmHeap.size   = sarea->tex_size;
 
907
      
 
908
   if (drmCommandWrite(ctx->drmFD, DRM_I830_INIT_HEAP,
 
909
                          &drmHeap, sizeof(drmHeap))) {
 
910
      fprintf(stderr,
 
911
                    "[drm] Failed to initialized agp heap manager\n");
 
912
   } else {
 
913
      fprintf(stderr,
 
914
                    "[drm] Initialized kernel agp heap manager, %d\n",
 
915
                    sarea->tex_size);
 
916
 
 
917
      I830SetParam(ctx, I830_SETPARAM_TEX_LRU_LOG_GRANULARITY, 
 
918
                      sarea->log_tex_granularity);
 
919
   }
 
920
}
 
921
#endif
 
922
 
 
923
static Bool
 
924
I830DRIDoMappings(DRIDriverContext *ctx, I830Rec *pI830, drmI830Sarea *sarea)
 
925
{
 
926
  if (drmAddMap(ctx->drmFD,
 
927
                (drm_handle_t)pI830->LpRing->mem.Start,
 
928
                pI830->LpRing->mem.Size, DRM_AGP, 0,
 
929
                &pI830->ring_map) < 0) {
 
930
    fprintf(stderr,
 
931
            "[drm] drmAddMap(ring_map) failed. Disabling DRI\n");
 
932
    return FALSE;
 
933
  }
 
934
  fprintf(stderr, "[drm] ring buffer = 0x%08x\n",
 
935
          pI830->ring_map);
 
936
 
 
937
  if (I830InitDma(ctx, pI830) == FALSE) {
 
938
    return FALSE;
 
939
  }
 
940
  
 
941
   /* init to zero to be safe */
 
942
 
 
943
  I830DRIMapScreenRegions(ctx, pI830, sarea);
 
944
  SetupDRIMM(ctx, pI830);
 
945
 
 
946
#if 0
 
947
  I830InitTextureHeap(ctx, pI830, sarea);
 
948
#endif
 
949
   if (ctx->pciDevice != PCI_CHIP_845_G &&
 
950
       ctx->pciDevice != PCI_CHIP_I830_M) {
 
951
      I830SetParam(ctx, I830_SETPARAM_USE_MI_BATCHBUFFER_START, 1 );
 
952
   }
 
953
 
 
954
   /* Okay now initialize the dma engine */
 
955
   {
 
956
      pI830->irq = drmGetInterruptFromBusID(ctx->drmFD,
 
957
                                            ctx->pciBus,
 
958
                                            ctx->pciDevice,
 
959
                                            ctx->pciFunc);
 
960
 
 
961
      if (drmCtlInstHandler(ctx->drmFD, pI830->irq)) {
 
962
         fprintf(stderr,
 
963
                    "[drm] failure adding irq handler\n");
 
964
         pI830->irq = 0;
 
965
         return FALSE;
 
966
      }
 
967
      else
 
968
         fprintf(stderr,
 
969
                    "[drm] dma control initialized, using IRQ %d\n",
 
970
                    pI830->irq);
 
971
   }
 
972
 
 
973
   fprintf(stderr, "[dri] visual configs initialized\n");
 
974
 
 
975
   return TRUE;
 
976
}
 
977
 
 
978
static Bool
 
979
I830ClearScreen(DRIDriverContext *ctx, I830Rec *pI830, drmI830Sarea *sarea)
 
980
{
 
981
  /* need to drmMap front and back buffers and zero them */
 
982
  drmAddress map_addr;
 
983
  int ret;
 
984
 
 
985
  ret = drmMap(ctx->drmFD,
 
986
               sarea->front_handle,
 
987
               sarea->front_size,
 
988
               &map_addr);
 
989
 
 
990
  if (ret)
 
991
  {
 
992
    fprintf(stderr, "Unable to map front buffer\n");
 
993
    return FALSE;
 
994
  }
 
995
 
 
996
  drimemsetio((char *)map_addr,
 
997
              0,
 
998
              sarea->front_size);
 
999
  drmUnmap(map_addr, sarea->front_size);
 
1000
 
 
1001
 
 
1002
  ret = drmMap(ctx->drmFD,
 
1003
               sarea->back_handle,
 
1004
               sarea->back_size,
 
1005
               &map_addr);
 
1006
 
 
1007
  if (ret)
 
1008
  {
 
1009
    fprintf(stderr, "Unable to map back buffer\n");
 
1010
    return FALSE;
 
1011
  }
 
1012
 
 
1013
  drimemsetio((char *)map_addr,
 
1014
              0,
 
1015
              sarea->back_size);
 
1016
  drmUnmap(map_addr, sarea->back_size);
 
1017
 
 
1018
  return TRUE;
 
1019
}
 
1020
 
 
1021
static Bool
 
1022
I830ScreenInit(DRIDriverContext *ctx, I830Rec *pI830)
 
1023
                  
 
1024
{
 
1025
   I830DRIPtr pI830DRI;
 
1026
   drmI830Sarea *pSAREAPriv;
 
1027
   int err;
 
1028
      
 
1029
   drm_page_size = getpagesize();   
 
1030
 
 
1031
   pI830->registerSize = ctx->MMIOSize;
 
1032
   /* This is a hack for now.  We have to have more than a 4k page here
 
1033
    * because of the size of the state.  However, the state should be
 
1034
    * in a per-context mapping.  This will be added in the Mesa 3.5 port
 
1035
    * of the I830 driver.
 
1036
    */
 
1037
   ctx->shared.SAREASize = SAREA_MAX;
 
1038
 
 
1039
   /* Note that drmOpen will try to load the kernel module, if needed. */
 
1040
   ctx->drmFD = drmOpen("i915", NULL );
 
1041
   if (ctx->drmFD < 0) {
 
1042
      fprintf(stderr, "[drm] drmOpen failed\n");
 
1043
      return 0;
 
1044
   }
 
1045
 
 
1046
   if ((err = drmSetBusid(ctx->drmFD, ctx->pciBusID)) < 0) {
 
1047
      fprintf(stderr, "[drm] drmSetBusid failed (%d, %s), %s\n",
 
1048
              ctx->drmFD, ctx->pciBusID, strerror(-err));
 
1049
      return 0;
 
1050
   }
 
1051
 
 
1052
   if (drmAddMap( ctx->drmFD,
 
1053
                  0,
 
1054
                  ctx->shared.SAREASize,
 
1055
                  DRM_SHM,
 
1056
                  DRM_CONTAINS_LOCK,
 
1057
                  &ctx->shared.hSAREA) < 0)
 
1058
   {
 
1059
     fprintf(stderr, "[drm] drmAddMap failed\n");
 
1060
     return 0;
 
1061
   }
 
1062
 
 
1063
   fprintf(stderr, "[drm] added %d byte SAREA at 0x%08x\n",
 
1064
           ctx->shared.SAREASize, ctx->shared.hSAREA);
 
1065
   
 
1066
   if (drmMap( ctx->drmFD,
 
1067
               ctx->shared.hSAREA,
 
1068
               ctx->shared.SAREASize,
 
1069
               (drmAddressPtr)(&ctx->pSAREA)) < 0)
 
1070
   {
 
1071
      fprintf(stderr, "[drm] drmMap failed\n");
 
1072
      return 0;
 
1073
   
 
1074
   }
 
1075
   
 
1076
   memset(ctx->pSAREA, 0, ctx->shared.SAREASize);
 
1077
   fprintf(stderr, "[drm] mapped SAREA 0x%08x to %p, size %d\n",
 
1078
           ctx->shared.hSAREA, ctx->pSAREA, ctx->shared.SAREASize);
 
1079
   
 
1080
 
 
1081
   if (drmAddMap(ctx->drmFD, 
 
1082
                 ctx->MMIOStart,
 
1083
                 ctx->MMIOSize,
 
1084
                 DRM_REGISTERS, 
 
1085
                 DRM_READ_ONLY, 
 
1086
                 &pI830->registerHandle) < 0) {
 
1087
      fprintf(stderr, "[drm] drmAddMap mmio failed\n"); 
 
1088
      return 0;
 
1089
   }
 
1090
   fprintf(stderr,
 
1091
           "[drm] register handle = 0x%08x\n", pI830->registerHandle);
 
1092
 
 
1093
 
 
1094
   if (!I830CheckDRMVersion(ctx, pI830)) {
 
1095
     return FALSE;
 
1096
   }
 
1097
 
 
1098
   /* Create a 'server' context so we can grab the lock for
 
1099
    * initialization ioctls.
 
1100
    */
 
1101
   if ((err = drmCreateContext(ctx->drmFD, &ctx->serverContext)) != 0) {
 
1102
      fprintf(stderr, "%s: drmCreateContext failed %d\n", __FUNCTION__, err);
 
1103
      return 0;
 
1104
   }
 
1105
 
 
1106
   DRM_LOCK(ctx->drmFD, ctx->pSAREA, ctx->serverContext, 0); 
 
1107
 
 
1108
   /* Initialize the SAREA private data structure */
 
1109
   pSAREAPriv = (drmI830Sarea *)(((char*)ctx->pSAREA) + 
 
1110
                                 sizeof(drm_sarea_t));
 
1111
   memset(pSAREAPriv, 0, sizeof(*pSAREAPriv));
 
1112
 
 
1113
   pI830->StolenMemory.Size = I830DetectMemory(ctx, pI830);
 
1114
   pI830->StolenMemory.Start = 0;
 
1115
   pI830->StolenMemory.End = pI830->StolenMemory.Size;
 
1116
 
 
1117
   pI830->MemoryAperture.Start = pI830->StolenMemory.End;
 
1118
   pI830->MemoryAperture.End = KB(40000);
 
1119
   pI830->MemoryAperture.Size = pI830->MemoryAperture.End - pI830->MemoryAperture.Start;
 
1120
 
 
1121
   pI830->StolenPool.Fixed = pI830->StolenMemory;
 
1122
   pI830->StolenPool.Total = pI830->StolenMemory;
 
1123
   pI830->StolenPool.Free = pI830->StolenPool.Total;
 
1124
   pI830->FreeMemory = pI830->StolenPool.Total.Size;
 
1125
 
 
1126
   if (!AgpInit(ctx, pI830))
 
1127
     return FALSE;
 
1128
 
 
1129
   if (I830AllocateMemory(ctx, pI830) == FALSE)
 
1130
   {
 
1131
     return FALSE;
 
1132
   }
 
1133
 
 
1134
   if (I830BindMemory(ctx, pI830) == FALSE)
 
1135
   {
 
1136
     return FALSE;
 
1137
   }
 
1138
 
 
1139
   pSAREAPriv->rotated_offset = -1;
 
1140
   pSAREAPriv->rotated_size = 0;
 
1141
   pSAREAPriv->rotated_pitch = ctx->shared.virtualWidth;
 
1142
 
 
1143
   pSAREAPriv->front_offset = pI830->FrontBuffer.Start;
 
1144
   pSAREAPriv->front_size = pI830->FrontBuffer.Size;
 
1145
   pSAREAPriv->width = ctx->shared.virtualWidth;
 
1146
   pSAREAPriv->height = ctx->shared.virtualHeight;
 
1147
   pSAREAPriv->pitch = ctx->shared.virtualWidth;
 
1148
   pSAREAPriv->virtualX = ctx->shared.virtualWidth;
 
1149
   pSAREAPriv->virtualY = ctx->shared.virtualHeight;
 
1150
   pSAREAPriv->back_offset = pI830->BackBuffer.Start;
 
1151
   pSAREAPriv->back_size = pI830->BackBuffer.Size;
 
1152
   pSAREAPriv->depth_offset = pI830->DepthBuffer.Start;
 
1153
   pSAREAPriv->depth_size = pI830->DepthBuffer.Size;
 
1154
#if 0
 
1155
   pSAREAPriv->tex_offset = pI830->TexMem.Start;
 
1156
   pSAREAPriv->tex_size = pI830->TexMem.Size;
 
1157
#endif
 
1158
   pSAREAPriv->log_tex_granularity = pI830->TexGranularity;
 
1159
 
 
1160
   ctx->driverClientMsg = malloc(sizeof(I830DRIRec));
 
1161
   ctx->driverClientMsgSize = sizeof(I830DRIRec);
 
1162
   pI830DRI = (I830DRIPtr)ctx->driverClientMsg;
 
1163
   pI830DRI->deviceID = pI830->Chipset;
 
1164
   pI830DRI->regsSize = I830_REG_SIZE;
 
1165
   pI830DRI->width = ctx->shared.virtualWidth;
 
1166
   pI830DRI->height = ctx->shared.virtualHeight;
 
1167
   pI830DRI->mem = ctx->shared.fbSize;
 
1168
   pI830DRI->cpp = ctx->cpp;
 
1169
 
 
1170
   pI830DRI->bitsPerPixel = ctx->bpp;
 
1171
   pI830DRI->sarea_priv_offset = sizeof(drm_sarea_t);
 
1172
   
 
1173
   err = I830DRIDoMappings(ctx, pI830, pSAREAPriv);
 
1174
   if (err == FALSE)
 
1175
       return FALSE;
 
1176
 
 
1177
   I830SetupMemoryTiling(ctx, pI830);
 
1178
 
 
1179
   /* Quick hack to clear the front & back buffers.  Could also use
 
1180
    * the clear ioctl to do this, but would need to setup hw state
 
1181
    * first.
 
1182
    */
 
1183
   I830ClearScreen(ctx, pI830, pSAREAPriv);
 
1184
 
 
1185
   I830SetRingRegs(ctx, pI830);
 
1186
 
 
1187
   return TRUE;
 
1188
}
 
1189
 
 
1190
 
 
1191
/**
 
1192
 * \brief Validate the fbdev mode.
 
1193
 * 
 
1194
 * \param ctx display handle.
 
1195
 *
 
1196
 * \return one on success, or zero on failure.
 
1197
 *
 
1198
 * Saves some registers and returns 1.
 
1199
 *
 
1200
 * \sa radeonValidateMode().
 
1201
 */
 
1202
static int i830ValidateMode( const DRIDriverContext *ctx )
 
1203
{
 
1204
  return 1;
 
1205
}
 
1206
 
 
1207
/**
 
1208
 * \brief Examine mode returned by fbdev.
 
1209
 * 
 
1210
 * \param ctx display handle.
 
1211
 *
 
1212
 * \return one on success, or zero on failure.
 
1213
 *
 
1214
 * Restores registers that fbdev has clobbered and returns 1.
 
1215
 *
 
1216
 * \sa i810ValidateMode().
 
1217
 */
 
1218
static int i830PostValidateMode( const DRIDriverContext *ctx )
 
1219
{
 
1220
  I830Rec *pI830 = ctx->driverPrivate;
 
1221
 
 
1222
  I830SetRingRegs(ctx, pI830);
 
1223
  return 1;
 
1224
}
 
1225
 
 
1226
 
 
1227
/**
 
1228
 * \brief Initialize the framebuffer device mode
 
1229
 *
 
1230
 * \param ctx display handle.
 
1231
 *
 
1232
 * \return one on success, or zero on failure.
 
1233
 *
 
1234
 * Fills in \p info with some default values and some information from \p ctx
 
1235
 * and then calls I810ScreenInit() for the screen initialization.
 
1236
 * 
 
1237
 * Before exiting clears the framebuffer memory accessing it directly.
 
1238
 */
 
1239
static int i830InitFBDev( DRIDriverContext *ctx )
 
1240
{
 
1241
  I830Rec *pI830 = calloc(1, sizeof(I830Rec));
 
1242
  int i;
 
1243
 
 
1244
   {
 
1245
      int  dummy = ctx->shared.virtualWidth;
 
1246
 
 
1247
      switch (ctx->bpp / 8) {
 
1248
      case 1: dummy = (ctx->shared.virtualWidth + 127) & ~127; break;
 
1249
      case 2: dummy = (ctx->shared.virtualWidth +  31) &  ~31; break;
 
1250
      case 3:
 
1251
      case 4: dummy = (ctx->shared.virtualWidth +  15) &  ~15; break;
 
1252
      }
 
1253
 
 
1254
      ctx->shared.virtualWidth = dummy;
 
1255
      ctx->shared.Width = ctx->shared.virtualWidth;
 
1256
   }
 
1257
 
 
1258
 
 
1259
   for (i = 0; pitches[i] != 0; i++) {
 
1260
     if (pitches[i] >= ctx->shared.virtualWidth) {
 
1261
       ctx->shared.virtualWidth = pitches[i];
 
1262
       break;
 
1263
     }
 
1264
   }
 
1265
 
 
1266
   ctx->driverPrivate = (void *)pI830;
 
1267
   
 
1268
   pI830->LpRing = calloc(1, sizeof(I830RingBuffer));
 
1269
   pI830->Chipset = ctx->chipset;
 
1270
   pI830->LinearAddr = ctx->FBStart;
 
1271
 
 
1272
   if (!I830ScreenInit( ctx, pI830 ))
 
1273
      return 0;
 
1274
 
 
1275
   
 
1276
   return 1;
 
1277
}
 
1278
 
 
1279
 
 
1280
/**
 
1281
 * \brief The screen is being closed, so clean up any state and free any
 
1282
 * resources used by the DRI.
 
1283
 *
 
1284
 * \param ctx display handle.
 
1285
 *
 
1286
 * Unmaps the SAREA, closes the DRM device file descriptor and frees the driver
 
1287
 * private data.
 
1288
 */
 
1289
static void i830HaltFBDev( DRIDriverContext *ctx )
 
1290
{
 
1291
  drmI830Sarea *pSAREAPriv;
 
1292
  I830Rec *pI830 = ctx->driverPrivate;
 
1293
 
 
1294
   if (pI830->irq) {
 
1295
       drmCtlUninstHandler(ctx->drmFD);
 
1296
       pI830->irq = 0;   }
 
1297
 
 
1298
   I830CleanupDma(ctx);
 
1299
 
 
1300
  pSAREAPriv = (drmI830Sarea *)(((char*)ctx->pSAREA) + 
 
1301
                                sizeof(drm_sarea_t));
 
1302
 
 
1303
  I830DRIUnmapScreenRegions(ctx, pI830, pSAREAPriv);
 
1304
  drmUnmap( ctx->pSAREA, ctx->shared.SAREASize );
 
1305
  drmClose(ctx->drmFD);
 
1306
  
 
1307
  if (ctx->driverPrivate) {
 
1308
    free(ctx->driverPrivate);
 
1309
    ctx->driverPrivate = 0;
 
1310
  }
 
1311
}
 
1312
 
 
1313
 
 
1314
extern void i810NotifyFocus( int );
 
1315
 
 
1316
/**
 
1317
 * \brief Exported driver interface for Mini GLX.
 
1318
 *
 
1319
 * \sa DRIDriverRec.
 
1320
 */
 
1321
const struct DRIDriverRec __driDriver = {
 
1322
   i830ValidateMode,
 
1323
   i830PostValidateMode,
 
1324
   i830InitFBDev,
 
1325
   i830HaltFBDev,
 
1326
   NULL,//I830EngineShutdown,
 
1327
   NULL, //I830EngineRestore,  
 
1328
#ifndef _EMBEDDED
 
1329
   0,
 
1330
#else
 
1331
   i810NotifyFocus, 
 
1332
#endif
 
1333
};