| File: | dummy_driver.c |
| Location: | line 690, column 2 |
| Description: | Value stored to 'Base' is never read |
| 1 | |
| 2 | /* |
| 3 | * Copyright 2002, SuSE Linux AG, Author: Egbert Eich |
| 4 | */ |
| 5 | |
| 6 | #ifdef HAVE_CONFIG_H1 |
| 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 XvExtension1 |
| 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_DGA1 |
| 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_DECLScreenPtr pScreen, int argc, char **argv); |
| 58 | static Bool DUMMYEnterVT(VT_FUNC_ARGS_DECLScrnInfoPtr arg); |
| 59 | static void DUMMYLeaveVT(VT_FUNC_ARGS_DECLScrnInfoPtr arg); |
| 60 | static Bool DUMMYCloseScreen(CLOSE_SCREEN_ARGS_DECLScreenPtr pScreen); |
| 61 | static Bool DUMMYCreateWindow(WindowPtr pWin); |
| 62 | static void DUMMYFreeScreen(FREE_SCREEN_ARGS_DECLScrnInfoPtr arg); |
| 63 | static ModeStatus DUMMYValidMode(SCRN_ARG_TYPEScrnInfoPtr 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_VERSION4000 4000 |
| 79 | #define DUMMY_NAME"DUMMY" "DUMMY" |
| 80 | #define DUMMY_DRIVER_NAME"dummy" "dummy" |
| 81 | |
| 82 | #define DUMMY_MAJOR_VERSION0 PACKAGE_VERSION_MAJOR0 |
| 83 | #define DUMMY_MINOR_VERSION3 PACKAGE_VERSION_MINOR3 |
| 84 | #define DUMMY_PATCHLEVEL7 PACKAGE_VERSION_PATCHLEVEL7 |
| 85 | |
| 86 | #define DUMMY_MAX_WIDTH32767 32767 |
| 87 | #define DUMMY_MAX_HEIGHT32767 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__attribute__((visibility("default"))) DriverRec DUMMY = { |
| 105 | DUMMY_VERSION4000, |
| 106 | DUMMY_DRIVER_NAME"dummy", |
| 107 | DUMMYIdentify, |
| 108 | DUMMYProbe, |
| 109 | DUMMYAvailableOptions, |
| 110 | NULL((void*)0), |
| 111 | 0, |
| 112 | dummyDriverFunc |
| 113 | }; |
| 114 | |
| 115 | static SymTabRec DUMMYChipsets[] = { |
| 116 | { DUMMY_CHIP, "dummy" }, |
| 117 | { -1, NULL((void*)0) } |
| 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}, FALSE0 }, |
| 126 | { -1, NULL((void*)0), OPTV_NONE, {0}, FALSE0 } |
| 127 | }; |
| 128 | |
| 129 | #ifdef XFree86LOADER |
| 130 | |
| 131 | static MODULESETUPPROTO(dummySetup)void *dummySetup(void *, void *, int*, int*); |
| 132 | |
| 133 | static XF86ModuleVersionInfo dummyVersRec = |
| 134 | { |
| 135 | "dummy", |
| 136 | MODULEVENDORSTRING"X.Org Foundation", |
| 137 | MODINFOSTRING10xef23fdc5, |
| 138 | MODINFOSTRING20x10dc023a, |
| 139 | XORG_VERSION_CURRENT(((1) * 10000000) + ((18) * 100000) + ((99) * 1000) + 1), |
| 140 | DUMMY_MAJOR_VERSION0, DUMMY_MINOR_VERSION3, DUMMY_PATCHLEVEL7, |
| 141 | ABI_CLASS_VIDEODRV"X.Org Video Driver", |
| 142 | ABI_VIDEODRV_VERSION((((22) << 16) & 0xFFFF0000) | ((0) & 0x0000FFFF )), |
| 143 | MOD_CLASS_VIDEODRV"X.Org Video Driver", |
| 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__attribute__((visibility("default"))) XF86ModuleData dummyModuleData = { &dummyVersRec, dummySetup, NULL((void*)0) }; |
| 152 | |
| 153 | static pointer |
| 154 | dummySetup(pointer module, pointer opts, int *errmaj, int *errmin) |
| 155 | { |
| 156 | static Bool setupDone = FALSE0; |
| 157 | |
| 158 | if (!setupDone) { |
| 159 | setupDone = TRUE1; |
| 160 | xf86AddDriver(&DUMMY, module, HaveDriverFuncs1); |
| 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((void*)0); |
| 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((void*)0)) |
| 189 | return TRUE1; |
| 190 | |
| 191 | pScrn->driverPrivate = xnfcalloc(sizeof(DUMMYRec), 1)XNFcallocarray((sizeof(DUMMYRec)), (1)); |
| 192 | |
| 193 | if (pScrn->driverPrivate == NULL((void*)0)) |
| 194 | return FALSE0; |
| 195 | return TRUE1; |
| 196 | } |
| 197 | |
| 198 | static void |
| 199 | DUMMYFreeRec(ScrnInfoPtr pScrn) |
| 200 | { |
| 201 | if (pScrn->driverPrivate == NULL((void*)0)) |
| 202 | return; |
| 203 | free(pScrn->driverPrivate); |
| 204 | pScrn->driverPrivate = NULL((void*)0); |
| 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"DUMMY", "Driver for Dummy chipsets", |
| 218 | DUMMYChipsets); |
| 219 | } |
| 220 | |
| 221 | /* Mandatory */ |
| 222 | static Bool |
| 223 | DUMMYProbe(DriverPtr drv, int flags) |
| 224 | { |
| 225 | Bool foundScreen = FALSE0; |
| 226 | int numDevSections, numUsed; |
| 227 | GDevPtr *devSections; |
| 228 | int i; |
| 229 | |
| 230 | if (flags & PROBE_DETECT0x01) |
| 231 | return FALSE0; |
| 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"dummy", |
| 237 | &devSections)) <= 0) { |
| 238 | return FALSE0; |
| 239 | } |
| 240 | |
| 241 | numUsed = numDevSections; |
| 242 | |
| 243 | if (numUsed > 0) { |
| 244 | |
| 245 | for (i = 0; i < numUsed; i++) { |
| 246 | ScrnInfoPtr pScrn = NULL((void*)0); |
| 247 | int entityIndex = |
| 248 | xf86ClaimNoSlot(drv,DUMMY_CHIP,devSections[i],TRUE1); |
| 249 | /* Allocate a ScrnInfoRec and claim the slot */ |
| 250 | if ((pScrn = xf86AllocateScreen(drv,0 ))) { |
| 251 | xf86AddEntityToScreen(pScrn,entityIndex); |
| 252 | pScrn->driverVersion = DUMMY_VERSION4000; |
| 253 | pScrn->driverName = DUMMY_DRIVER_NAME"dummy"; |
| 254 | pScrn->name = DUMMY_NAME"DUMMY"; |
| 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 = TRUE1; |
| 266 | } |
| 267 | } |
| 268 | } |
| 269 | return foundScreen; |
| 270 | } |
| 271 | |
| 272 | # define RETURN \ |
| 273 | { DUMMYFreeRec(pScrn);\ |
| 274 | return FALSE0;\ |
| 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 = 300000; |
| 285 | GDevPtr device = xf86GetEntityInfo(pScrn->entityList[0])->device; |
| 286 | |
| 287 | if (flags & PROBE_DETECT0x01) |
| 288 | return TRUE1; |
| 289 | |
| 290 | /* Allocate the DummyRec driverPrivate */ |
| 291 | if (!DUMMYGetRec(pScrn)) { |
| 292 | return FALSE0; |
| 293 | } |
| 294 | |
| 295 | dPtr = DUMMYPTR(pScrn)((DUMMYPtr)((pScrn)->driverPrivate)); |
| 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, Support24bppFb0x01 | Support32bppFb0x02)) |
| 305 | return FALSE0; |
| 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 FALSE0; |
| 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 FALSE0; |
| 340 | } else { |
| 341 | /* XXX check that weight returned is supported */ |
| 342 | ; |
| 343 | } |
| 344 | } |
| 345 | |
| 346 | if (!xf86SetDefaultVisual(pScrn, -1)) |
| 347 | return FALSE0; |
| 348 | |
| 349 | if (pScrn->depth > 1) { |
| 350 | Gamma zeros = {0.0, 0.0, 0.0}; |
| 351 | |
| 352 | if (!xf86SetGamma(pScrn, zeros)) |
| 353 | return FALSE0; |
| 354 | } |
| 355 | |
| 356 | xf86CollectOptions(pScrn, device->options); |
| 357 | /* Process the options */ |
| 358 | if (!(dPtr->Options = malloc(sizeof(DUMMYOptions)))) |
| 359 | return FALSE0; |
| 360 | memcpy(dPtr->Options, DUMMYOptions, sizeof(DUMMYOptions))__builtin___memcpy_chk (dPtr->Options, DUMMYOptions, sizeof (DUMMYOptions), __builtin_object_size (dPtr->Options, 0)); |
| 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 = TRUE1; |
| 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)XNFcallocarray((sizeof(ClockRange)), (1)); |
| 391 | clockRanges->next = NULL((void*)0); |
| 392 | clockRanges->ClockMulFactor = 1; |
| 393 | clockRanges->minClock = 11000; /* guessed ยงยงยง */ |
| 394 | clockRanges->maxClock = maxClock; |
| 395 | clockRanges->clockIndex = -1; /* programmable */ |
| 396 | clockRanges->interlaceAllowed = TRUE1; |
| 397 | clockRanges->doubleScanAllowed = TRUE1; |
| 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((void*)0), 256, DUMMY_MAX_WIDTH32767, |
| 407 | (8 * pScrn->bitsPerPixel), |
| 408 | 128, DUMMY_MAX_HEIGHT32767, 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((void*)0)) { |
| 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((void*)0)) { |
| 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 TRUE1; |
| 457 | } |
| 458 | #undef RETURN |
| 459 | |
| 460 | /* Mandatory */ |
| 461 | static Bool |
| 462 | DUMMYEnterVT(VT_FUNC_ARGS_DECLScrnInfoPtr arg) |
| 463 | { |
| 464 | SCRN_INFO_PTR(arg)ScrnInfoPtr pScrn = (arg); |
| 465 | |
| 466 | /* Should we re-save the text mode on each VT enter? */ |
| 467 | if(!dummyModeInit(pScrn, pScrn->currentMode)) |
| 468 | return FALSE0; |
| 469 | |
| 470 | DUMMYAdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0)pScrn, pScrn->frameX0, pScrn->frameY0); |
| 471 | |
| 472 | return TRUE1; |
| 473 | } |
| 474 | |
| 475 | /* Mandatory */ |
| 476 | static void |
| 477 | DUMMYLeaveVT(VT_FUNC_ARGS_DECLScrnInfoPtr arg) |
| 478 | { |
| 479 | SCRN_INFO_PTR(arg)ScrnInfoPtr pScrn = (arg); |
| 480 | dummyRestore(pScrn, TRUE1); |
| 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)((DUMMYPtr)((pScrn)->driverPrivate)); |
| 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_DECLScreenPtr pScreen, int argc, char **argv) |
| 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)((DUMMYPtr)((pScrn)->driverPrivate)); |
| 533 | DUMMYScrn = pScrn; |
| 534 | |
| 535 | |
| 536 | if (!(dPtr->FBBase = malloc(pScrn->videoRam * 1024))) |
| 537 | return FALSE0; |
| 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 FALSE0; |
| 546 | DUMMYAdjustFrame(ADJUST_FRAME_ARGS(pScrn, pScrn->frameX0, pScrn->frameY0)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 FALSE0; |
| 559 | |
| 560 | if (!miSetPixmapDepths ()) return FALSE0; |
| 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 FALSE0; |
| 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 | DynamicClass1) == DirectColor5) { |
| 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_DGA1 |
| 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 FALSE0; |
| 630 | } |
| 631 | } |
| 632 | |
| 633 | /* Initialise default colourmap */ |
| 634 | if(!miCreateDefColormap(pScreen)) |
| 635 | return FALSE0; |
| 636 | |
| 637 | if (!xf86HandleColormaps(pScreen, 256, pScrn->rgbBits, |
| 638 | DUMMYLoadPalette, NULL((void*)0), |
| 639 | CMAP_PALETTED_TRUECOLOR0x0000001 |
| 640 | | CMAP_RELOAD_ON_MODE_SWITCH0x0000002)) |
| 641 | return FALSE0; |
| 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 TRUE1; |
| 662 | } |
| 663 | |
| 664 | /* Mandatory */ |
| 665 | Bool |
| 666 | DUMMYSwitchMode(SWITCH_MODE_ARGS_DECLScrnInfoPtr arg, DisplayModePtr mode) |
| 667 | { |
| 668 | SCRN_INFO_PTR(arg)ScrnInfoPtr pScrn = (arg); |
| 669 | return dummyModeInit(pScrn, mode); |
| 670 | } |
| 671 | |
| 672 | /* Mandatory */ |
| 673 | void |
| 674 | DUMMYAdjustFrame(ADJUST_FRAME_ARGS_DECLScrnInfoPtr arg, int x, int y) |
| 675 | { |
| 676 | SCRN_INFO_PTR(arg)ScrnInfoPtr pScrn = (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; |
Value stored to 'Base' is never read | |
| 691 | break; |
| 692 | default : |
| 693 | break; |
| 694 | } |
| 695 | } |
| 696 | |
| 697 | /* Mandatory */ |
| 698 | static Bool |
| 699 | DUMMYCloseScreen(CLOSE_SCREEN_ARGS_DECLScreenPtr pScreen) |
| 700 | { |
| 701 | ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); |
| 702 | DUMMYPtr dPtr = DUMMYPTR(pScrn)((DUMMYPtr)((pScrn)->driverPrivate)); |
| 703 | |
| 704 | if(pScrn->vtSema){ |
| 705 | dummyRestore(pScrn, TRUE1); |
| 706 | free(dPtr->FBBase); |
| 707 | } |
| 708 | |
| 709 | if (dPtr->CursorInfo) |
| 710 | xf86DestroyCursorInfoRec(dPtr->CursorInfo); |
| 711 | |
| 712 | pScrn->vtSema = FALSE0; |
| 713 | pScreen->CloseScreen = dPtr->CloseScreen; |
| 714 | return (*pScreen->CloseScreen)(CLOSE_SCREEN_ARGSpScreen); |
| 715 | } |
| 716 | |
| 717 | /* Optional */ |
| 718 | static void |
| 719 | DUMMYFreeScreen(FREE_SCREEN_ARGS_DECLScrnInfoPtr arg) |
| 720 | { |
| 721 | SCRN_INFO_PTR(arg)ScrnInfoPtr pScrn = (arg); |
| 722 | DUMMYFreeRec(pScrn); |
| 723 | } |
| 724 | |
| 725 | static Bool |
| 726 | DUMMYSaveScreen(ScreenPtr pScreen, int mode) |
| 727 | { |
| 728 | ScrnInfoPtr pScrn = NULL((void*)0); |
| 729 | DUMMYPtr dPtr; |
| 730 | |
| 731 | if (pScreen != NULL((void*)0)) { |
| 732 | pScrn = xf86ScreenToScrn(pScreen); |
| 733 | dPtr = DUMMYPTR(pScrn)((DUMMYPtr)((pScrn)->driverPrivate)); |
| 734 | |
| 735 | dPtr->screenSaver = xf86IsUnblank(mode); |
| 736 | } |
| 737 | return TRUE1; |
| 738 | } |
| 739 | |
| 740 | /* Optional */ |
| 741 | static ModeStatus |
| 742 | DUMMYValidMode(SCRN_ARG_TYPEScrnInfoPtr 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, FALSE0); |
| 761 | |
| 762 | return(TRUE1); |
| 763 | } |
| 764 | |
| 765 | Atom VFB_PROP = 0; |
| 766 | #define VFB_PROP_NAME"VFB_IDENT" "VFB_IDENT" |
| 767 | |
| 768 | static Bool |
| 769 | DUMMYCreateWindow(WindowPtr pWin) |
| 770 | { |
| 771 | ScreenPtr pScreen = pWin->drawable.pScreen; |
| 772 | DUMMYPtr dPtr = DUMMYPTR(DUMMYScrn)((DUMMYPtr)((DUMMYScrn)->driverPrivate)); |
| 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 != TRUE1) |
| 782 | return(ret); |
| 783 | |
| 784 | if(dPtr->prop == FALSE0) { |
| 785 | #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION)(((((((22) << 16) & 0xFFFF0000) | ((0) & 0x0000FFFF ))) & 0xFFFF0000) >> 16) < 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"VFB_IDENT", strlen(VFB_PROP_NAME"VFB_IDENT"), 1); |
| 792 | |
| 793 | ret = dixChangeWindowProperty(serverClient, pWinRoot, VFB_PROP, |
| 794 | XA_STRING((Atom) 31), 8, PropModeReplace0, |
| 795 | (int)4, (pointer)"TRUE", FALSE0); |
| 796 | if( ret != Success0) |
| 797 | ErrorF("Could not set VFB root window property"); |
| 798 | dPtr->prop = TRUE1; |
| 799 | |
| 800 | return TRUE1; |
| 801 | } |
| 802 | return TRUE1; |
| 803 | } |
| 804 | |
| 805 | #ifndef HW_SKIP_CONSOLE4 |
| 806 | #define HW_SKIP_CONSOLE4 4 |
| 807 | #endif |
| 808 | |
| 809 | static Bool |
| 810 | dummyDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, pointer ptr) |
| 811 | { |
| 812 | CARD32 *flag; |
| 813 | |
| 814 | switch (op) { |
| 815 | case GET_REQUIRED_HW_INTERFACES: |
| 816 | flag = (CARD32*)ptr; |
| 817 | (*flag) = HW_SKIP_CONSOLE4; |
| 818 | return TRUE1; |
| 819 | default: |
| 820 | return FALSE0; |
| 821 | } |
| 822 | } |