← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xserver-xorg-video-dummy-lts-utopic/trusty-proposed

« back to all changes in this revision

Viewing changes to src/dummy_driver.c

  • Committer: Package Import Robot
  • Author(s): Maarten Lankhorst
  • Date: 2015-01-06 10:39:13 UTC
  • Revision ID: package-import@ubuntu.com-20150106103913-fjjsho4g2a4ziord
Tags: upstream-0.3.7
Import upstream version 0.3.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dummy_driver.c
 
1
 
 
2
/*
 
3
 * Copyright 2002, SuSE Linux AG, Author: Egbert Eich
 
4
 */
 
5
 
 
6
#ifdef HAVE_CONFIG_H
 
7
#include "config.h"
 
8
#endif
 
9
 
 
10
/* All drivers should typically include these */
 
11
#include "xf86.h"
 
12
#include "xf86_OSproc.h"
 
13
 
 
14
/* All drivers initialising the SW cursor need this */
 
15
#include "mipointer.h"
 
16
 
 
17
/* All drivers using the mi colormap manipulation need this */
 
18
#include "micmap.h"
 
19
 
 
20
/* identifying atom needed by magnifiers */
 
21
#include <X11/Xatom.h>
 
22
#include "property.h"
 
23
 
 
24
#include "xf86cmap.h"
 
25
 
 
26
#include "xf86fbman.h"
 
27
 
 
28
#include "fb.h"
 
29
 
 
30
#include "picturestr.h"
 
31
 
 
32
#ifdef XvExtension
 
33
#include "xf86xv.h"
 
34
#include <X11/extensions/Xv.h>
 
35
#endif
 
36
 
 
37
/*
 
38
 * Driver data structures.
 
39
 */
 
40
#include "dummy.h"
 
41
 
 
42
/* These need to be checked */
 
43
#include <X11/X.h>
 
44
#include <X11/Xproto.h>
 
45
#include "scrnintstr.h"
 
46
#include "servermd.h"
 
47
#ifdef USE_DGA
 
48
#define _XF86DGA_SERVER_
 
49
#include <X11/extensions/xf86dgaproto.h>
 
50
#endif
 
51
 
 
52
/* Mandatory functions */
 
53
static const OptionInfoRec *    DUMMYAvailableOptions(int chipid, int busid);
 
54
static void     DUMMYIdentify(int flags);
 
55
static Bool     DUMMYProbe(DriverPtr drv, int flags);
 
56
static Bool     DUMMYPreInit(ScrnInfoPtr pScrn, int flags);
 
57
static Bool     DUMMYScreenInit(SCREEN_INIT_ARGS_DECL);
 
58
static Bool     DUMMYEnterVT(VT_FUNC_ARGS_DECL);
 
59
static void     DUMMYLeaveVT(VT_FUNC_ARGS_DECL);
 
60
static Bool     DUMMYCloseScreen(CLOSE_SCREEN_ARGS_DECL);
 
61
static Bool     DUMMYCreateWindow(WindowPtr pWin);
 
62
static void     DUMMYFreeScreen(FREE_SCREEN_ARGS_DECL);
 
63
static ModeStatus DUMMYValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode,
 
64
                                 Bool verbose, int flags);
 
65
static Bool     DUMMYSaveScreen(ScreenPtr pScreen, int mode);
 
66
 
 
67
/* Internally used functions */
 
68
static Bool     dummyModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode);
 
69
static void     dummySave(ScrnInfoPtr pScrn);
 
70
static void     dummyRestore(ScrnInfoPtr pScrn, Bool restoreText);
 
71
static Bool     dummyDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op,
 
72
                                pointer ptr);
 
73
 
 
74
 
 
75
/* static void     DUMMYDisplayPowerManagementSet(ScrnInfoPtr pScrn, */
 
76
/*                              int PowerManagementMode, int flags); */
 
77
 
 
78
#define DUMMY_VERSION 4000
 
79
#define DUMMY_NAME "DUMMY"
 
80
#define DUMMY_DRIVER_NAME "dummy"
 
81
 
 
82
#define DUMMY_MAJOR_VERSION PACKAGE_VERSION_MAJOR
 
83
#define DUMMY_MINOR_VERSION PACKAGE_VERSION_MINOR
 
84
#define DUMMY_PATCHLEVEL PACKAGE_VERSION_PATCHLEVEL
 
85
 
 
86
#define DUMMY_MAX_WIDTH 32767
 
87
#define DUMMY_MAX_HEIGHT 32767
 
88
 
 
89
/*
 
90
 * This is intentionally screen-independent.  It indicates the binding
 
91
 * choice made in the first PreInit.
 
92
 */
 
93
static int pix24bpp = 0;
 
94
 
 
95
 
 
96
/*
 
97
 * This contains the functions needed by the server after loading the driver
 
98
 * module.  It must be supplied, and gets passed back by the SetupProc
 
99
 * function in the dynamic case.  In the static case, a reference to this
 
100
 * is compiled in, and this requires that the name of this DriverRec be
 
101
 * an upper-case version of the driver name.
 
102
 */
 
103
 
 
104
_X_EXPORT DriverRec DUMMY = {
 
105
    DUMMY_VERSION,
 
106
    DUMMY_DRIVER_NAME,
 
107
    DUMMYIdentify,
 
108
    DUMMYProbe,
 
109
    DUMMYAvailableOptions,
 
110
    NULL,
 
111
    0,
 
112
    dummyDriverFunc
 
113
};
 
114
 
 
115
static SymTabRec DUMMYChipsets[] = {
 
116
    { DUMMY_CHIP,   "dummy" },
 
117
    { -1,                NULL }
 
118
};
 
119
 
 
120
typedef enum {
 
121
    OPTION_SW_CURSOR
 
122
} DUMMYOpts;
 
123
 
 
124
static const OptionInfoRec DUMMYOptions[] = {
 
125
    { OPTION_SW_CURSOR, "SWcursor",     OPTV_BOOLEAN,   {0}, FALSE },
 
126
    { -1,                  NULL,           OPTV_NONE,   {0}, FALSE }
 
127
};
 
128
 
 
129
#ifdef XFree86LOADER
 
130
 
 
131
static MODULESETUPPROTO(dummySetup);
 
132
 
 
133
static XF86ModuleVersionInfo dummyVersRec =
 
134
{
 
135
        "dummy",
 
136
        MODULEVENDORSTRING,
 
137
        MODINFOSTRING1,
 
138
        MODINFOSTRING2,
 
139
        XORG_VERSION_CURRENT,
 
140
        DUMMY_MAJOR_VERSION, DUMMY_MINOR_VERSION, DUMMY_PATCHLEVEL,
 
141
        ABI_CLASS_VIDEODRV,
 
142
        ABI_VIDEODRV_VERSION,
 
143
        MOD_CLASS_VIDEODRV,
 
144
        {0,0,0,0}
 
145
};
 
146
 
 
147
/*
 
148
 * This is the module init data.
 
149
 * Its name has to be the driver name followed by ModuleData
 
150
 */
 
151
_X_EXPORT XF86ModuleData dummyModuleData = { &dummyVersRec, dummySetup, NULL };
 
152
 
 
153
static pointer
 
154
dummySetup(pointer module, pointer opts, int *errmaj, int *errmin)
 
155
{
 
156
    static Bool setupDone = FALSE;
 
157
 
 
158
    if (!setupDone) {
 
159
        setupDone = TRUE;
 
160
        xf86AddDriver(&DUMMY, module, HaveDriverFuncs);
 
161
 
 
162
        /*
 
163
         * Modules that this driver always requires can be loaded here
 
164
         * by calling LoadSubModule().
 
165
         */
 
166
 
 
167
        /*
 
168
         * The return value must be non-NULL on success even though there
 
169
         * is no TearDownProc.
 
170
         */
 
171
        return (pointer)1;
 
172
    } else {
 
173
        if (errmaj) *errmaj = LDR_ONCEONLY;
 
174
        return NULL;
 
175
    }
 
176
}
 
177
 
 
178
#endif /* XFree86LOADER */
 
179
 
 
180
static Bool
 
181
DUMMYGetRec(ScrnInfoPtr pScrn)
 
182
{
 
183
    /*
 
184
     * Allocate a DUMMYRec, and hook it into pScrn->driverPrivate.
 
185
     * pScrn->driverPrivate is initialised to NULL, so we can check if
 
186
     * the allocation has already been done.
 
187
     */
 
188
    if (pScrn->driverPrivate != NULL)
 
189
        return TRUE;
 
190
 
 
191
    pScrn->driverPrivate = xnfcalloc(sizeof(DUMMYRec), 1);
 
192
 
 
193
    if (pScrn->driverPrivate == NULL)
 
194
        return FALSE;
 
195
        return TRUE;
 
196
}
 
197
 
 
198
static void
 
199
DUMMYFreeRec(ScrnInfoPtr pScrn)
 
200
{
 
201
    if (pScrn->driverPrivate == NULL)
 
202
        return;
 
203
    free(pScrn->driverPrivate);
 
204
    pScrn->driverPrivate = NULL;
 
205
}
 
206
 
 
207
static const OptionInfoRec *
 
208
DUMMYAvailableOptions(int chipid, int busid)
 
209
{
 
210
    return DUMMYOptions;
 
211
}
 
212
 
 
213
/* Mandatory */
 
214
static void
 
215
DUMMYIdentify(int flags)
 
216
{
 
217
    xf86PrintChipsets(DUMMY_NAME, "Driver for Dummy chipsets",
 
218
                        DUMMYChipsets);
 
219
}
 
220
 
 
221
/* Mandatory */
 
222
static Bool
 
223
DUMMYProbe(DriverPtr drv, int flags)
 
224
{
 
225
    Bool foundScreen = FALSE;
 
226
    int numDevSections, numUsed;
 
227
    GDevPtr *devSections;
 
228
    int i;
 
229
 
 
230
    if (flags & PROBE_DETECT)
 
231
        return FALSE;
 
232
    /*
 
233
     * Find the config file Device sections that match this
 
234
     * driver, and return if there are none.
 
235
     */
 
236
    if ((numDevSections = xf86MatchDevice(DUMMY_DRIVER_NAME,
 
237
                                          &devSections)) <= 0) {
 
238
        return FALSE;
 
239
    }
 
240
 
 
241
    numUsed = numDevSections;
 
242
 
 
243
    if (numUsed > 0) {
 
244
 
 
245
        for (i = 0; i < numUsed; i++) {
 
246
            ScrnInfoPtr pScrn = NULL;
 
247
            int entityIndex = 
 
248
                xf86ClaimNoSlot(drv,DUMMY_CHIP,devSections[i],TRUE);
 
249
            /* Allocate a ScrnInfoRec and claim the slot */
 
250
            if ((pScrn = xf86AllocateScreen(drv,0 ))) {
 
251
                   xf86AddEntityToScreen(pScrn,entityIndex);
 
252
                    pScrn->driverVersion = DUMMY_VERSION;
 
253
                    pScrn->driverName    = DUMMY_DRIVER_NAME;
 
254
                    pScrn->name          = DUMMY_NAME;
 
255
                    pScrn->Probe         = DUMMYProbe;
 
256
                    pScrn->PreInit       = DUMMYPreInit;
 
257
                    pScrn->ScreenInit    = DUMMYScreenInit;
 
258
                    pScrn->SwitchMode    = DUMMYSwitchMode;
 
259
                    pScrn->AdjustFrame   = DUMMYAdjustFrame;
 
260
                    pScrn->EnterVT       = DUMMYEnterVT;
 
261
                    pScrn->LeaveVT       = DUMMYLeaveVT;
 
262
                    pScrn->FreeScreen    = DUMMYFreeScreen;
 
263
                    pScrn->ValidMode     = DUMMYValidMode;
 
264
 
 
265
                    foundScreen = TRUE;
 
266
            }
 
267
        }
 
268
    }    
 
269
    return foundScreen;
 
270
}
 
271
 
 
272
# define RETURN \
 
273
    { DUMMYFreeRec(pScrn);\
 
274
                            return FALSE;\
 
275
                                             }
 
276
 
 
277
/* Mandatory */
 
278
Bool
 
279
DUMMYPreInit(ScrnInfoPtr pScrn, int flags)
 
280
{
 
281
    ClockRangePtr clockRanges;
 
282
    int i;
 
283
    DUMMYPtr dPtr;
 
284
    int maxClock = 230000;
 
285
    GDevPtr device = xf86GetEntityInfo(pScrn->entityList[0])->device;
 
286
 
 
287
    if (flags & PROBE_DETECT) 
 
288
        return TRUE;
 
289
    
 
290
    /* Allocate the DummyRec driverPrivate */
 
291
    if (!DUMMYGetRec(pScrn)) {
 
292
        return FALSE;
 
293
    }
 
294
    
 
295
    dPtr = DUMMYPTR(pScrn);
 
296
 
 
297
    pScrn->chipset = (char *)xf86TokenToString(DUMMYChipsets,
 
298
                                               DUMMY_CHIP);
 
299
 
 
300
    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Chipset is a DUMMY\n");
 
301
    
 
302
    pScrn->monitor = pScrn->confScreen->monitor;
 
303
 
 
304
    if (!xf86SetDepthBpp(pScrn, 0, 0, 0,  Support24bppFb | Support32bppFb))
 
305
        return FALSE;
 
306
    else {
 
307
        /* Check that the returned depth is one we support */
 
308
        switch (pScrn->depth) {
 
309
        case 8:
 
310
        case 15:
 
311
        case 16:
 
312
        case 24:
 
313
            break;
 
314
        default:
 
315
            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 
316
                       "Given depth (%d) is not supported by this driver\n",
 
317
                       pScrn->depth);
 
318
            return FALSE;
 
319
        }
 
320
    }
 
321
 
 
322
    xf86PrintDepthBpp(pScrn);
 
323
    if (pScrn->depth == 8)
 
324
        pScrn->rgbBits = 8;
 
325
 
 
326
    /* Get the depth24 pixmap format */
 
327
    if (pScrn->depth == 24 && pix24bpp == 0)
 
328
        pix24bpp = xf86GetBppFromDepth(pScrn, 24);
 
329
 
 
330
    /*
 
331
     * This must happen after pScrn->display has been set because
 
332
     * xf86SetWeight references it.
 
333
     */
 
334
    if (pScrn->depth > 8) {
 
335
        /* The defaults are OK for us */
 
336
        rgb zeros = {0, 0, 0};
 
337
 
 
338
        if (!xf86SetWeight(pScrn, zeros, zeros)) {
 
339
            return FALSE;
 
340
        } else {
 
341
            /* XXX check that weight returned is supported */
 
342
            ;
 
343
        }
 
344
    }
 
345
 
 
346
    if (!xf86SetDefaultVisual(pScrn, -1)) 
 
347
        return FALSE;
 
348
 
 
349
    if (pScrn->depth > 1) {
 
350
        Gamma zeros = {0.0, 0.0, 0.0};
 
351
 
 
352
        if (!xf86SetGamma(pScrn, zeros))
 
353
            return FALSE;
 
354
    }
 
355
 
 
356
    xf86CollectOptions(pScrn, device->options);
 
357
    /* Process the options */
 
358
    if (!(dPtr->Options = malloc(sizeof(DUMMYOptions))))
 
359
        return FALSE;
 
360
    memcpy(dPtr->Options, DUMMYOptions, sizeof(DUMMYOptions));
 
361
 
 
362
    xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, dPtr->Options);
 
363
 
 
364
    xf86GetOptValBool(dPtr->Options, OPTION_SW_CURSOR,&dPtr->swCursor);
 
365
 
 
366
    if (device->videoRam != 0) {
 
367
        pScrn->videoRam = device->videoRam;
 
368
        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "VideoRAM: %d kByte\n",
 
369
                   pScrn->videoRam);
 
370
    } else {
 
371
        pScrn->videoRam = 4096;
 
372
        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "VideoRAM: %d kByte\n",
 
373
                   pScrn->videoRam);
 
374
    }
 
375
    
 
376
    if (device->dacSpeeds[0] != 0) {
 
377
        maxClock = device->dacSpeeds[0];
 
378
        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Max Clock: %d kHz\n",
 
379
                   maxClock);
 
380
    } else {
 
381
        xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Max Clock: %d kHz\n",
 
382
                   maxClock);
 
383
    }
 
384
 
 
385
    pScrn->progClock = TRUE;
 
386
    /*
 
387
     * Setup the ClockRanges, which describe what clock ranges are available,
 
388
     * and what sort of modes they can be used for.
 
389
     */
 
390
    clockRanges = (ClockRangePtr)xnfcalloc(sizeof(ClockRange), 1);
 
391
    clockRanges->next = NULL;
 
392
    clockRanges->ClockMulFactor = 1;
 
393
    clockRanges->minClock = 11000;   /* guessed §§§ */
 
394
    clockRanges->maxClock = 300000;
 
395
    clockRanges->clockIndex = -1;               /* programmable */
 
396
    clockRanges->interlaceAllowed = TRUE; 
 
397
    clockRanges->doubleScanAllowed = TRUE;
 
398
 
 
399
    /* Subtract memory for HW cursor */
 
400
 
 
401
 
 
402
    {
 
403
        int apertureSize = (pScrn->videoRam * 1024);
 
404
        i = xf86ValidateModes(pScrn, pScrn->monitor->Modes,
 
405
                              pScrn->display->modes, clockRanges,
 
406
                              NULL, 256, DUMMY_MAX_WIDTH,
 
407
                              (8 * pScrn->bitsPerPixel),
 
408
                              128, DUMMY_MAX_HEIGHT, pScrn->display->virtualX,
 
409
                              pScrn->display->virtualY, apertureSize,
 
410
                              LOOKUP_BEST_REFRESH);
 
411
 
 
412
       if (i == -1)
 
413
           RETURN;
 
414
    }
 
415
 
 
416
    /* Prune the modes marked as invalid */
 
417
    xf86PruneDriverModes(pScrn);
 
418
 
 
419
    if (i == 0 || pScrn->modes == NULL) {
 
420
        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
 
421
        RETURN;
 
422
    }
 
423
 
 
424
    /*
 
425
     * Set the CRTC parameters for all of the modes based on the type
 
426
     * of mode, and the chipset's interlace requirements.
 
427
     *
 
428
     * Calling this is required if the mode->Crtc* values are used by the
 
429
     * driver and if the driver doesn't provide code to set them.  They
 
430
     * are not pre-initialised at all.
 
431
     */
 
432
    xf86SetCrtcForModes(pScrn, 0); 
 
433
 
 
434
    /* Set the current mode to the first in the list */
 
435
    pScrn->currentMode = pScrn->modes;
 
436
 
 
437
    /* Print the list of modes being used */
 
438
    xf86PrintModes(pScrn);
 
439
 
 
440
    /* If monitor resolution is set on the command line, use it */
 
441
    xf86SetDpi(pScrn, 0, 0);
 
442
 
 
443
    if (xf86LoadSubModule(pScrn, "fb") == NULL) {
 
444
        RETURN;
 
445
    }
 
446
 
 
447
    if (!dPtr->swCursor) {
 
448
        if (!xf86LoadSubModule(pScrn, "ramdac"))
 
449
            RETURN;
 
450
    }
 
451
    
 
452
    /* We have no contiguous physical fb in physical memory */
 
453
    pScrn->memPhysBase = 0;
 
454
    pScrn->fbOffset = 0;
 
455
 
 
456
    return TRUE;
 
457
}
 
458
#undef RETURN
 
459
 
 
460
/* Mandatory */
 
461
static Bool
 
462
DUMMYEnterVT(VT_FUNC_ARGS_DECL)
 
463
{
 
464
    SCRN_INFO_PTR(arg);
 
465
    
 
466
    /* Should we re-save the text mode on each VT enter? */
 
467
    if(!dummyModeInit(pScrn, pScrn->currentMode))
 
468
      return FALSE;
 
469
 
 
470
    DUMMYAdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
 
471
 
 
472
    return TRUE;
 
473
}
 
474
 
 
475
/* Mandatory */
 
476
static void
 
477
DUMMYLeaveVT(VT_FUNC_ARGS_DECL)
 
478
{
 
479
    SCRN_INFO_PTR(arg);
 
480
    dummyRestore(pScrn, TRUE);
 
481
}
 
482
 
 
483
static void
 
484
DUMMYLoadPalette(
 
485
   ScrnInfoPtr pScrn,
 
486
   int numColors,
 
487
   int *indices,
 
488
   LOCO *colors,
 
489
   VisualPtr pVisual
 
490
){
 
491
   int i, index, shift, Gshift;
 
492
   DUMMYPtr dPtr = DUMMYPTR(pScrn);
 
493
 
 
494
   switch(pScrn->depth) {
 
495
   case 15:     
 
496
        shift = Gshift = 1;
 
497
        break;
 
498
   case 16:
 
499
        shift = 0; 
 
500
        Gshift = 0;
 
501
        break;
 
502
   default:
 
503
        shift = Gshift = 0;
 
504
        break;
 
505
   }
 
506
 
 
507
   for(i = 0; i < numColors; i++) {
 
508
       index = indices[i];
 
509
       dPtr->colors[index].red = colors[index].red << shift;
 
510
       dPtr->colors[index].green = colors[index].green << Gshift;
 
511
       dPtr->colors[index].blue = colors[index].blue << shift;
 
512
   } 
 
513
 
 
514
}
 
515
 
 
516
static ScrnInfoPtr DUMMYScrn; /* static-globalize it */
 
517
 
 
518
/* Mandatory */
 
519
static Bool
 
520
DUMMYScreenInit(SCREEN_INIT_ARGS_DECL)
 
521
{
 
522
    ScrnInfoPtr pScrn;
 
523
    DUMMYPtr dPtr;
 
524
    int ret;
 
525
    VisualPtr visual;
 
526
    
 
527
    /*
 
528
     * we need to get the ScrnInfoRec for this screen, so let's allocate
 
529
     * one first thing
 
530
     */
 
531
    pScrn = xf86ScreenToScrn(pScreen);
 
532
    dPtr = DUMMYPTR(pScrn);
 
533
    DUMMYScrn = pScrn;
 
534
 
 
535
 
 
536
    if (!(dPtr->FBBase = malloc(pScrn->videoRam * 1024)))
 
537
        return FALSE;
 
538
    
 
539
    /*
 
540
     * next we save the current state and setup the first mode
 
541
     */
 
542
    dummySave(pScrn);
 
543
    
 
544
    if (!dummyModeInit(pScrn,pScrn->currentMode))
 
545
        return FALSE;
 
546
    DUMMYAdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0));
 
547
 
 
548
    /*
 
549
     * Reset visual list.
 
550
     */
 
551
    miClearVisualTypes();
 
552
    
 
553
    /* Setup the visuals we support. */
 
554
    
 
555
    if (!miSetVisualTypes(pScrn->depth,
 
556
                      miGetDefaultVisualMask(pScrn->depth),
 
557
                      pScrn->rgbBits, pScrn->defaultVisual))
 
558
         return FALSE;
 
559
 
 
560
    if (!miSetPixmapDepths ()) return FALSE;
 
561
 
 
562
    /*
 
563
     * Call the framebuffer layer's ScreenInit function, and fill in other
 
564
     * pScreen fields.
 
565
     */
 
566
    ret = fbScreenInit(pScreen, dPtr->FBBase,
 
567
                            pScrn->virtualX, pScrn->virtualY,
 
568
                            pScrn->xDpi, pScrn->yDpi,
 
569
                            pScrn->displayWidth, pScrn->bitsPerPixel);
 
570
    if (!ret)
 
571
        return FALSE;
 
572
 
 
573
    if (pScrn->depth > 8) {
 
574
        /* Fixup RGB ordering */
 
575
        visual = pScreen->visuals + pScreen->numVisuals;
 
576
        while (--visual >= pScreen->visuals) {
 
577
            if ((visual->class | DynamicClass) == DirectColor) {
 
578
                visual->offsetRed = pScrn->offset.red;
 
579
                visual->offsetGreen = pScrn->offset.green;
 
580
                visual->offsetBlue = pScrn->offset.blue;
 
581
                visual->redMask = pScrn->mask.red;
 
582
                visual->greenMask = pScrn->mask.green;
 
583
                visual->blueMask = pScrn->mask.blue;
 
584
            }
 
585
        }
 
586
    }
 
587
    
 
588
    /* must be after RGB ordering fixed */
 
589
    fbPictureInit(pScreen, 0, 0);
 
590
 
 
591
    xf86SetBlackWhitePixels(pScreen);
 
592
 
 
593
#ifdef USE_DGA
 
594
    DUMMYDGAInit(pScreen);
 
595
#endif
 
596
    
 
597
    if (dPtr->swCursor)
 
598
        xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Using Software Cursor.\n");
 
599
 
 
600
    {
 
601
 
 
602
         
 
603
        BoxRec AvailFBArea;
 
604
        int lines = pScrn->videoRam * 1024 /
 
605
            (pScrn->displayWidth * (pScrn->bitsPerPixel >> 3));
 
606
        AvailFBArea.x1 = 0;
 
607
        AvailFBArea.y1 = 0;
 
608
        AvailFBArea.x2 = pScrn->displayWidth;
 
609
        AvailFBArea.y2 = lines;
 
610
        xf86InitFBManager(pScreen, &AvailFBArea); 
 
611
        
 
612
        xf86DrvMsg(pScrn->scrnIndex, X_INFO, 
 
613
                   "Using %i scanlines of offscreen memory \n"
 
614
                   , lines - pScrn->virtualY);
 
615
    }
 
616
 
 
617
    xf86SetBackingStore(pScreen);
 
618
    xf86SetSilkenMouse(pScreen);
 
619
        
 
620
    /* Initialise cursor functions */
 
621
    miDCInitialize (pScreen, xf86GetPointerScreenFuncs());
 
622
 
 
623
 
 
624
    if (!dPtr->swCursor) {
 
625
      /* HW cursor functions */
 
626
      if (!DUMMYCursorInit(pScreen)) {
 
627
          xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 
628
                     "Hardware cursor initialization failed\n");
 
629
          return FALSE;
 
630
      }
 
631
    }
 
632
    
 
633
    /* Initialise default colourmap */
 
634
    if(!miCreateDefColormap(pScreen))
 
635
        return FALSE;
 
636
 
 
637
    if (!xf86HandleColormaps(pScreen, 256, pScrn->rgbBits,
 
638
                         DUMMYLoadPalette, NULL, 
 
639
                         CMAP_PALETTED_TRUECOLOR 
 
640
                             | CMAP_RELOAD_ON_MODE_SWITCH))
 
641
        return FALSE;
 
642
 
 
643
/*     DUMMYInitVideo(pScreen); */
 
644
 
 
645
    pScreen->SaveScreen = DUMMYSaveScreen;
 
646
 
 
647
    
 
648
    /* Wrap the current CloseScreen function */
 
649
    dPtr->CloseScreen = pScreen->CloseScreen;
 
650
    pScreen->CloseScreen = DUMMYCloseScreen;
 
651
 
 
652
    /* Wrap the current CreateWindow function */
 
653
    dPtr->CreateWindow = pScreen->CreateWindow;
 
654
    pScreen->CreateWindow = DUMMYCreateWindow;
 
655
 
 
656
    /* Report any unused options (only for the first generation) */
 
657
    if (serverGeneration == 1) {
 
658
        xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
 
659
    }
 
660
 
 
661
    return TRUE;
 
662
}
 
663
 
 
664
/* Mandatory */
 
665
Bool
 
666
DUMMYSwitchMode(SWITCH_MODE_ARGS_DECL)
 
667
{
 
668
    SCRN_INFO_PTR(arg);
 
669
    return dummyModeInit(pScrn, mode);
 
670
}
 
671
 
 
672
/* Mandatory */
 
673
void
 
674
DUMMYAdjustFrame(ADJUST_FRAME_ARGS_DECL)
 
675
{
 
676
    SCRN_INFO_PTR(arg);
 
677
    int Base; 
 
678
 
 
679
    Base = (y * pScrn->displayWidth + x) >> 2;
 
680
 
 
681
    /* Scale Base by the number of bytes per pixel. */
 
682
    switch (pScrn->depth) {
 
683
    case  8 :
 
684
        break;
 
685
    case 15 :
 
686
    case 16 :
 
687
        Base *= 2;
 
688
        break;
 
689
    case 24 :
 
690
        Base *= 3;
 
691
        break;
 
692
    default :
 
693
        break;
 
694
    }
 
695
}
 
696
 
 
697
/* Mandatory */
 
698
static Bool
 
699
DUMMYCloseScreen(CLOSE_SCREEN_ARGS_DECL)
 
700
{
 
701
    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
 
702
    DUMMYPtr dPtr = DUMMYPTR(pScrn);
 
703
 
 
704
    if(pScrn->vtSema){
 
705
        dummyRestore(pScrn, TRUE);
 
706
        free(dPtr->FBBase);
 
707
    }
 
708
 
 
709
    if (dPtr->CursorInfo)
 
710
        xf86DestroyCursorInfoRec(dPtr->CursorInfo);
 
711
 
 
712
    pScrn->vtSema = FALSE;
 
713
    pScreen->CloseScreen = dPtr->CloseScreen;
 
714
    return (*pScreen->CloseScreen)(CLOSE_SCREEN_ARGS);
 
715
}
 
716
 
 
717
/* Optional */
 
718
static void
 
719
DUMMYFreeScreen(FREE_SCREEN_ARGS_DECL)
 
720
{
 
721
    SCRN_INFO_PTR(arg);
 
722
    DUMMYFreeRec(pScrn);
 
723
}
 
724
 
 
725
static Bool
 
726
DUMMYSaveScreen(ScreenPtr pScreen, int mode)
 
727
{
 
728
    ScrnInfoPtr pScrn = NULL;
 
729
    DUMMYPtr dPtr;
 
730
 
 
731
    if (pScreen != NULL) {
 
732
        pScrn = xf86ScreenToScrn(pScreen);
 
733
        dPtr = DUMMYPTR(pScrn);
 
734
 
 
735
        dPtr->screenSaver = xf86IsUnblank(mode);
 
736
    } 
 
737
    return TRUE;
 
738
}
 
739
 
 
740
/* Optional */
 
741
static ModeStatus
 
742
DUMMYValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode, Bool verbose, int flags)
 
743
{
 
744
    return(MODE_OK);
 
745
}
 
746
 
 
747
static void
 
748
dummySave(ScrnInfoPtr pScrn)
 
749
{
 
750
}
 
751
 
 
752
static void 
 
753
dummyRestore(ScrnInfoPtr pScrn, Bool restoreText)
 
754
{
 
755
}
 
756
    
 
757
static Bool
 
758
dummyModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
 
759
{
 
760
    dummyRestore(pScrn, FALSE);
 
761
    
 
762
    return(TRUE);
 
763
}
 
764
 
 
765
Atom VFB_PROP  = 0;
 
766
#define  VFB_PROP_NAME  "VFB_IDENT"
 
767
 
 
768
static Bool
 
769
DUMMYCreateWindow(WindowPtr pWin)
 
770
{
 
771
    ScreenPtr pScreen = pWin->drawable.pScreen;
 
772
    DUMMYPtr dPtr = DUMMYPTR(DUMMYScrn);
 
773
    WindowPtr pWinRoot;
 
774
    int ret;
 
775
 
 
776
    pScreen->CreateWindow = dPtr->CreateWindow;
 
777
    ret = pScreen->CreateWindow(pWin);
 
778
    dPtr->CreateWindow = pScreen->CreateWindow;
 
779
    pScreen->CreateWindow = DUMMYCreateWindow;
 
780
 
 
781
    if(ret != TRUE)
 
782
        return(ret);
 
783
        
 
784
    if(dPtr->prop == FALSE) {
 
785
#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 8
 
786
        pWinRoot = WindowTable[DUMMYScrn->pScreen->myNum];
 
787
#else
 
788
        pWinRoot = DUMMYScrn->pScreen->root;
 
789
#endif
 
790
        if (! ValidAtom(VFB_PROP))
 
791
            VFB_PROP = MakeAtom(VFB_PROP_NAME, strlen(VFB_PROP_NAME), 1);
 
792
 
 
793
        ret = ChangeWindowProperty(pWinRoot, VFB_PROP, XA_STRING, 
 
794
                8, PropModeReplace, (int)4, (pointer)"TRUE", FALSE);
 
795
        if( ret != Success)
 
796
                ErrorF("Could not set VFB root window property");
 
797
        dPtr->prop = TRUE;
 
798
 
 
799
        return TRUE;
 
800
    }
 
801
    return TRUE;
 
802
}
 
803
 
 
804
#ifndef HW_SKIP_CONSOLE
 
805
#define HW_SKIP_CONSOLE 4
 
806
#endif
 
807
 
 
808
static Bool
 
809
dummyDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, pointer ptr)
 
810
{
 
811
    CARD32 *flag;
 
812
    
 
813
    switch (op) {
 
814
        case GET_REQUIRED_HW_INTERFACES:
 
815
            flag = (CARD32*)ptr;
 
816
            (*flag) = HW_SKIP_CONSOLE;
 
817
            return TRUE;
 
818
        default:
 
819
            return FALSE;
 
820
    }
 
821
}