![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to enable.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3|
Return to enable.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: enable.c ! 3: * ! 4: * This module contains the functions that enable and disable the ! 5: * driver, the pdev, and the surface. ! 6: * ! 7: * Copyright (c) 1992 Microsoft Corporation ! 8: \**************************************************************************/ ! 9: ! 10: #include "driver.h" ! 11: ! 12: #define GDI_MODE 1 ! 13: #define FULL_SCREEN_MODE 2 ! 14: ! 15: ULONG gLastState = GDI_MODE; ! 16: ! 17: #if DBG ! 18: ! 19: ULONG gCount = 1; ! 20: ! 21: DHPDEV WDrvEnablePDEV( ! 22: DEVMODEW *pDevmode, // Pointer to DEVMODE ! 23: PWSTR pwszLogAddress, // Logical address ! 24: ULONG cPatterns, // number of patterns ! 25: HSURF *ahsurfPatterns, // return standard patterns ! 26: ULONG cjGdiInfo, // Length of memory pointed to by pGdiInfo ! 27: ULONG *pGdiInfo, // Pointer to GdiInfo structure ! 28: ULONG cjDevInfo, // Length of following PDEVINFO structure ! 29: DEVINFO *pDevInfo, // physical device information structure ! 30: PWSTR pwszDataFile, // DataFile - not used ! 31: PWSTR pwszDeviceName, // DeviceName - not used ! 32: HANDLE hDriver) // Handle to base driver ! 33: { ! 34: DHPDEV bRet; ! 35: ! 36: LOGDBG((1, "DrvEnablePDEV\n")); ! 37: ! 38: if (InterlockedDecrement(&gCount) != 0) ! 39: RIP("Somebody else is in here\n"); ! 40: ! 41: bRet = DrvEnablePDEV( ! 42: pDevmode, ! 43: pwszLogAddress, ! 44: cPatterns, ! 45: ahsurfPatterns, ! 46: cjGdiInfo, ! 47: pGdiInfo, ! 48: cjDevInfo, ! 49: pDevInfo, ! 50: pwszDataFile, ! 51: pwszDeviceName, ! 52: hDriver); ! 53: ! 54: if (InterlockedIncrement(&gCount) <= 0) ! 55: RIP("Can't leave\n"); ! 56: ! 57: LOGDBG((5, "DrvEnablePDEV done\n")); ! 58: ! 59: return(bRet); ! 60: } ! 61: ! 62: VOID WDrvCompletePDEV( ! 63: DHPDEV dhpdev, ! 64: HDEV hdev) ! 65: { ! 66: LOGDBG((1, "DrvCompletePDEV\n")); ! 67: ! 68: if (InterlockedDecrement(&gCount) != 0) ! 69: RIP("Somebody else is in here\n"); ! 70: ! 71: DrvCompletePDEV( ! 72: dhpdev, ! 73: hdev); ! 74: ! 75: if (InterlockedIncrement(&gCount) <= 0) ! 76: RIP("Can't leave\n"); ! 77: ! 78: LOGDBG((5, "DrvCompletePDEV done\n")); ! 79: } ! 80: ! 81: VOID WDrvDisablePDEV(DHPDEV dhpdev) ! 82: { ! 83: LOGDBG((1, "DrvDisable\n")); ! 84: ! 85: DrvDisablePDEV(dhpdev); ! 86: ! 87: LOGDBG((5, "DrvDisable done\n")); ! 88: } ! 89: ! 90: HSURF WDrvEnableSurface(DHPDEV dhpdev) ! 91: { ! 92: HSURF h; ! 93: ! 94: LOGDBG((1, "DrvEnableSurface\n")); ! 95: ! 96: if (InterlockedDecrement(&gCount) != 0) ! 97: RIP("Somebody else is in here\n"); ! 98: ! 99: h = DrvEnableSurface(dhpdev); ! 100: ! 101: if (InterlockedIncrement(&gCount) <= 0) ! 102: RIP("Can't leave\n"); ! 103: ! 104: LOGDBG((5, "DrvEnableSurface done\n")); ! 105: ! 106: return(h); ! 107: } ! 108: ! 109: VOID WDrvDisableSurface(DHPDEV dhpdev) ! 110: { ! 111: LOGDBG((1, "DrvDisableSurface\n")); ! 112: ! 113: DrvDisableSurface(dhpdev); ! 114: ! 115: LOGDBG((5, "DrvDisableSurface done\n")); ! 116: } ! 117: ! 118: ! 119: VOID WDrvAssertMode( ! 120: DHPDEV dhpdev, ! 121: BOOL bEnable) ! 122: { ! 123: LOGDBG((1, "DrvAssertMode\n")); ! 124: ! 125: if (bEnable) ! 126: { ! 127: // When the driver is active we'll always expect gCount to be ! 128: // one at the beginning of any driver call: ! 129: ! 130: if (InterlockedIncrement(&gCount) <= 0) ! 131: RIP("Somebody else is in here\n"); ! 132: } ! 133: else ! 134: { ! 135: if (InterlockedDecrement(&gCount) != 0) ! 136: RIP("Somebody else is in here\n"); ! 137: } ! 138: ! 139: DrvAssertMode(dhpdev,bEnable); ! 140: ! 141: LOGDBG((5, "DrvAssertMode done\n")); ! 142: } ! 143: ! 144: ! 145: VOID WDrvMovePointer(SURFOBJ *pso,LONG x,LONG y,RECTL *prcl) ! 146: { ! 147: LOGDBG((1, "DrvMovePointer\n")); ! 148: ! 149: if (InterlockedDecrement(&gCount) != 0) ! 150: RIP("Somebody else is in here\n"); ! 151: ! 152: DrvMovePointer(pso,x,y,prcl); ! 153: ! 154: if (InterlockedIncrement(&gCount) <= 0) ! 155: RIP("Can't leave\n"); ! 156: ! 157: LOGDBG((5, "DrvMovePointer done\n")); ! 158: } ! 159: ! 160: ULONG WDrvSetPointerShape( ! 161: SURFOBJ *pso, ! 162: SURFOBJ *psoMask, ! 163: SURFOBJ *psoColor, ! 164: XLATEOBJ *pxlo, ! 165: LONG xHot, ! 166: LONG yHot, ! 167: LONG x, ! 168: LONG y, ! 169: RECTL *prcl, ! 170: FLONG fl) ! 171: { ! 172: ULONG u; ! 173: ! 174: LOGDBG((1, "DrvSetPointerShape\n")); ! 175: ! 176: if (InterlockedDecrement(&gCount) != 0) ! 177: RIP("Somebody else is in here\n"); ! 178: ! 179: u = DrvSetPointerShape( ! 180: pso, ! 181: psoMask, ! 182: psoColor, ! 183: pxlo, ! 184: xHot, ! 185: yHot, ! 186: x, ! 187: y, ! 188: prcl, ! 189: fl); ! 190: ! 191: if (InterlockedIncrement(&gCount) <= 0) ! 192: RIP("Can't leave\n"); ! 193: ! 194: LOGDBG((5, "DrvSetPointerShape done\n")); ! 195: ! 196: return(u); ! 197: } ! 198: ! 199: ULONG WDrvDitherColor( ! 200: DHPDEV dhpdev, ! 201: ULONG iMode, ! 202: ULONG rgb, ! 203: ULONG *pul) ! 204: { ! 205: ULONG u; ! 206: ! 207: LOGDBG((1, "DrvDitherColor\n")); ! 208: ! 209: u = DrvDitherColor( ! 210: dhpdev, ! 211: iMode, ! 212: rgb, ! 213: pul); ! 214: ! 215: LOGDBG((5, "DrvDitherColor done\n")); ! 216: ! 217: return(u); ! 218: } ! 219: ! 220: ! 221: BOOL WDrvSetPalette( ! 222: DHPDEV dhpdev, ! 223: PALOBJ *ppalo, ! 224: FLONG fl, ! 225: ULONG iStart, ! 226: ULONG cColors) ! 227: { ! 228: BOOL u; ! 229: ! 230: LOGDBG((1, "DrvSetPalette\n")); ! 231: ! 232: if (InterlockedDecrement(&gCount) != 0) ! 233: RIP("Somebody else is in here\n"); ! 234: ! 235: u = DrvSetPalette( ! 236: dhpdev, ! 237: ppalo, ! 238: fl, ! 239: iStart, ! 240: cColors); ! 241: ! 242: ! 243: if (InterlockedIncrement(&gCount) <= 0) ! 244: RIP("Can't leave\n"); ! 245: ! 246: LOGDBG((5, "DrvSetPalette done\n")); ! 247: ! 248: return(u); ! 249: } ! 250: ! 251: BOOL WDrvCopyBits( ! 252: SURFOBJ *psoDest, ! 253: SURFOBJ *psoSrc, ! 254: CLIPOBJ *pco, ! 255: XLATEOBJ *pxlo, ! 256: RECTL *prclDest, ! 257: POINTL *pptlSrc) ! 258: { ! 259: BOOL u; ! 260: ! 261: LOGDBG((1, "DrvCopyBits\n")); ! 262: ! 263: if (InterlockedDecrement(&gCount) != 0) ! 264: RIP("Somebody else is in here\n"); ! 265: ! 266: u = DrvCopyBits( ! 267: psoDest, ! 268: psoSrc, ! 269: pco, ! 270: pxlo, ! 271: prclDest, ! 272: pptlSrc); ! 273: ! 274: if (InterlockedIncrement(&gCount) <= 0) ! 275: RIP("Can't leave\n"); ! 276: ! 277: LOGDBG((5, "DrvCopyBits done\n")); ! 278: ! 279: return(u); ! 280: } ! 281: ! 282: ! 283: BOOL WDrvBitBlt( ! 284: SURFOBJ *psoTrg, ! 285: SURFOBJ *psoSrc, ! 286: SURFOBJ *psoMask, ! 287: CLIPOBJ *pco, ! 288: XLATEOBJ *pxlo, ! 289: RECTL *prclTrg, ! 290: POINTL *pptlSrc, ! 291: POINTL *pptlMask, ! 292: BRUSHOBJ *pbo, ! 293: POINTL *pptlBrush, ! 294: ROP4 rop4) ! 295: { ! 296: BOOL u; ! 297: ! 298: LOGDBG((1, "DrvBitBlt\n")); ! 299: ! 300: if (InterlockedDecrement(&gCount) != 0) ! 301: RIP("Somebody else is in here\n"); ! 302: ! 303: u = DrvBitBlt( ! 304: psoTrg, ! 305: psoSrc, ! 306: psoMask, ! 307: pco, ! 308: pxlo, ! 309: prclTrg, ! 310: pptlSrc, ! 311: pptlMask, ! 312: pbo, ! 313: pptlBrush, ! 314: rop4); ! 315: ! 316: if (InterlockedIncrement(&gCount) <= 0) ! 317: RIP("Can't leave\n"); ! 318: ! 319: LOGDBG((5, "DrvBitBlt done\n")); ! 320: ! 321: return(u); ! 322: } ! 323: ! 324: BOOL WDrvTextOut( ! 325: SURFOBJ *pso, ! 326: STROBJ *pstro, ! 327: FONTOBJ *pfo, ! 328: CLIPOBJ *pco, ! 329: RECTL *prclExtra, ! 330: RECTL *prclOpaque, ! 331: BRUSHOBJ *pboFore, ! 332: BRUSHOBJ *pboOpaque, ! 333: POINTL *pptlOrg, ! 334: MIX mix) ! 335: { ! 336: BOOL u; ! 337: ! 338: LOGDBG((1, "DrvTextOut\n")); ! 339: ! 340: if (InterlockedDecrement(&gCount) != 0) ! 341: RIP("Somebody else is in here\n"); ! 342: ! 343: u = DrvTextOut( ! 344: pso, ! 345: pstro, ! 346: pfo, ! 347: pco, ! 348: prclExtra, ! 349: prclOpaque, ! 350: pboFore, ! 351: pboOpaque, ! 352: pptlOrg, ! 353: mix); ! 354: ! 355: if (InterlockedIncrement(&gCount) <= 0) ! 356: RIP("Can't leave\n"); ! 357: ! 358: LOGDBG((5, "DrvTextOut done\n")); ! 359: ! 360: return(u); ! 361: } ! 362: ! 363: ULONG WDrvGetModes( ! 364: HANDLE hDriver, ! 365: ULONG cjSize, ! 366: DEVMODEW *pdm) ! 367: { ! 368: ULONG u; ! 369: ! 370: LOGDBG((1, "DrvGetModes\n")); ! 371: ! 372: if (InterlockedDecrement(&gCount) != 0) ! 373: RIP("Somebody else is in here\n"); ! 374: ! 375: u = DrvGetModes( ! 376: hDriver, ! 377: cjSize, ! 378: pdm); ! 379: ! 380: if (InterlockedIncrement(&gCount) <= 0) ! 381: RIP("Can't leave\n"); ! 382: ! 383: LOGDBG((5, "DrvGetModes done\n")); ! 384: ! 385: return(u); ! 386: } ! 387: ! 388: BOOL WDrvStrokePath( ! 389: SURFOBJ *pso, ! 390: PATHOBJ *ppo, ! 391: CLIPOBJ *pco, ! 392: XFORMOBJ *pxo, ! 393: BRUSHOBJ *pbo, ! 394: POINTL *pptlBrushOrg, ! 395: LINEATTRS *plineattrs, ! 396: MIX mix) ! 397: { ! 398: BOOL u; ! 399: ! 400: LOGDBG((1, "DrvStrokePath\n")); ! 401: ! 402: if (InterlockedDecrement(&gCount) != 0) ! 403: RIP("Somebody else is in here\n"); ! 404: ! 405: u = DrvStrokePath( ! 406: pso, ! 407: ppo, ! 408: pco, ! 409: pxo, ! 410: pbo, ! 411: pptlBrushOrg, ! 412: plineattrs, ! 413: mix); ! 414: ! 415: if (InterlockedIncrement(&gCount) <= 0) ! 416: RIP("Can't leave\n"); ! 417: ! 418: LOGDBG((5, "DrvStrokePath done\n")); ! 419: ! 420: return(u); ! 421: } ! 422: ! 423: ! 424: BOOL WDrvFillPath( ! 425: SURFOBJ *pso, ! 426: PATHOBJ *ppo, ! 427: CLIPOBJ *pco, ! 428: BRUSHOBJ *pbo, ! 429: POINTL *pptlBrushOrg, ! 430: MIX mix, ! 431: FLONG flOptions) ! 432: { ! 433: BOOL u; ! 434: ! 435: LOGDBG((1, "DrvFillPath\n")); ! 436: ! 437: if (InterlockedDecrement(&gCount) != 0) ! 438: RIP("Somebody else is in here\n"); ! 439: ! 440: u = DrvFillPath(pso, ! 441: ppo, ! 442: pco, ! 443: pbo, ! 444: pptlBrushOrg, ! 445: mix, ! 446: flOptions); ! 447: ! 448: if (InterlockedIncrement(&gCount) <= 0) ! 449: RIP("Can't leave\n"); ! 450: ! 451: LOGDBG((5, "DrvFillPath done\n")); ! 452: ! 453: return(u); ! 454: } ! 455: ! 456: BOOL WDrvPaint( ! 457: SURFOBJ *pso, ! 458: CLIPOBJ *pco, ! 459: BRUSHOBJ *pbo, ! 460: POINTL *pptlBrushOrg, ! 461: MIX mix) ! 462: { ! 463: BOOL u; ! 464: ! 465: LOGDBG((1, "DrvPaint\n")); ! 466: ! 467: if (InterlockedDecrement(&gCount) != 0) ! 468: RIP("Somebody else is in here\n"); ! 469: ! 470: u = DrvPaint( ! 471: pso, ! 472: pco, ! 473: pbo, ! 474: pptlBrushOrg, ! 475: mix); ! 476: ! 477: if (InterlockedIncrement(&gCount) <= 0) ! 478: RIP("Can't leave\n"); ! 479: ! 480: LOGDBG((5, "DrvPaint done\n")); ! 481: ! 482: return(u); ! 483: } ! 484: ! 485: BOOL WDrvRealizeBrush( ! 486: BRUSHOBJ *pbo, ! 487: SURFOBJ *psoTarget, ! 488: SURFOBJ *psoPattern, ! 489: SURFOBJ *psoMask, ! 490: XLATEOBJ *pxlo, ! 491: ULONG iHatch) ! 492: { ! 493: BOOL u; ! 494: ! 495: LOGDBG((1, "DrvRealizeBrush\n")); ! 496: ! 497: if (gCount != 0) ! 498: RIP("DrvRealizeBrush Somebody else is in here\n"); ! 499: ! 500: u = DrvRealizeBrush( ! 501: pbo, ! 502: psoTarget, ! 503: psoPattern, ! 504: psoMask, ! 505: pxlo, ! 506: iHatch); ! 507: ! 508: LOGDBG((5, "DrvRealizeBrush done\n")); ! 509: ! 510: return(u); ! 511: } ! 512: ! 513: ULONG WDrvSaveScreenBits(SURFOBJ *pso,ULONG iMode,ULONG ident,RECTL *prcl) ! 514: { ! 515: ULONG u; ! 516: ! 517: LOGDBG((1, "DrvSaveScreenBits\n")); ! 518: ! 519: if (InterlockedDecrement(&gCount) != 0) ! 520: RIP("Somebody else is in here\n"); ! 521: ! 522: u = DrvSaveScreenBits(pso,iMode,ident,prcl); ! 523: ! 524: if (InterlockedIncrement(&gCount) <= 0) ! 525: RIP("Can't leave\n"); ! 526: ! 527: LOGDBG((5, "DrvSaveScreenBits done\n")); ! 528: ! 529: return(u); ! 530: } ! 531: ! 532: VOID WDrvDestroyFont(FONTOBJ *pfo) ! 533: { ! 534: LOGDBG((1, "DrvDestroyFont\n")); ! 535: ! 536: // !!! if (InterlockedDecrement(&gCount) != 0) ! 537: // !!! RIP("Somebody else is in here\n"); ! 538: ! 539: DrvDestroyFont(pfo); ! 540: ! 541: // !!! if (InterlockedIncrement(&gCount) <= 0) ! 542: // !!! RIP("Can't leave\n"); ! 543: ! 544: LOGDBG((5, "DrvDestroyFont done\n")); ! 545: } ! 546: ! 547: // ! 548: // On a checked build, we thunk all driver calls for debugging purposes: ! 549: // ! 550: ! 551: DRVFN gadrvfn[] = { ! 552: { INDEX_DrvEnablePDEV, (PFN) WDrvEnablePDEV }, ! 553: { INDEX_DrvCompletePDEV, (PFN) WDrvCompletePDEV }, ! 554: { INDEX_DrvDisablePDEV, (PFN) WDrvDisablePDEV }, ! 555: { INDEX_DrvEnableSurface, (PFN) WDrvEnableSurface }, ! 556: { INDEX_DrvDisableSurface, (PFN) WDrvDisableSurface }, ! 557: { INDEX_DrvAssertMode, (PFN) WDrvAssertMode }, ! 558: { INDEX_DrvMovePointer, (PFN) WDrvMovePointer }, ! 559: { INDEX_DrvSetPointerShape, (PFN) WDrvSetPointerShape }, ! 560: { INDEX_DrvDitherColor, (PFN) WDrvDitherColor }, ! 561: { INDEX_DrvSetPalette, (PFN) WDrvSetPalette }, ! 562: { INDEX_DrvCopyBits, (PFN) WDrvCopyBits }, ! 563: { INDEX_DrvBitBlt, (PFN) WDrvBitBlt }, ! 564: { INDEX_DrvTextOut, (PFN) WDrvTextOut }, ! 565: { INDEX_DrvGetModes, (PFN) WDrvGetModes }, ! 566: { INDEX_DrvStrokePath, (PFN) WDrvStrokePath }, ! 567: { INDEX_DrvFillPath, (PFN) WDrvFillPath }, ! 568: { INDEX_DrvPaint, (PFN) WDrvPaint }, ! 569: { INDEX_DrvRealizeBrush, (PFN) WDrvRealizeBrush }, ! 570: { INDEX_DrvSaveScreenBits, (PFN) WDrvSaveScreenBits }, ! 571: { INDEX_DrvDestroyFont, (PFN) WDrvDestroyFont } ! 572: }; ! 573: ! 574: #else ! 575: ! 576: // ! 577: // Build the driver function table gadrvfn with function index/address pairs ! 578: // ! 579: ! 580: DRVFN gadrvfn[] = { ! 581: { INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV }, ! 582: { INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV }, ! 583: { INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV }, ! 584: { INDEX_DrvEnableSurface, (PFN) DrvEnableSurface }, ! 585: { INDEX_DrvDisableSurface, (PFN) DrvDisableSurface }, ! 586: { INDEX_DrvAssertMode, (PFN) DrvAssertMode }, ! 587: { INDEX_DrvMovePointer, (PFN) DrvMovePointer }, ! 588: { INDEX_DrvSetPointerShape, (PFN) DrvSetPointerShape }, ! 589: { INDEX_DrvDitherColor, (PFN) DrvDitherColor }, ! 590: { INDEX_DrvSetPalette, (PFN) DrvSetPalette }, ! 591: { INDEX_DrvCopyBits, (PFN) DrvCopyBits }, ! 592: { INDEX_DrvBitBlt, (PFN) DrvBitBlt }, ! 593: { INDEX_DrvTextOut, (PFN) DrvTextOut }, ! 594: { INDEX_DrvGetModes, (PFN) DrvGetModes }, ! 595: { INDEX_DrvStrokePath, (PFN) DrvStrokePath }, ! 596: { INDEX_DrvFillPath, (PFN) DrvFillPath }, ! 597: { INDEX_DrvPaint, (PFN) DrvPaint }, ! 598: { INDEX_DrvRealizeBrush, (PFN) DrvRealizeBrush }, ! 599: { INDEX_DrvSaveScreenBits, (PFN) DrvSaveScreenBits }, ! 600: { INDEX_DrvDestroyFont, (PFN) DrvDestroyFont } ! 601: }; ! 602: #endif ! 603: ! 604: /******************************Public*Routine******************************\ ! 605: * DrvEnableDriver ! 606: * ! 607: * Enables the driver by retrieving the drivers function table and version. ! 608: * ! 609: \**************************************************************************/ ! 610: ! 611: BOOL DrvEnableDriver( ! 612: ULONG iEngineVersion, ! 613: ULONG cj, ! 614: PDRVENABLEDATA pded) ! 615: { ! 616: UNREFERENCED_PARAMETER(iEngineVersion); ! 617: ! 618: DISPDBG((2, "*** S3.DLL!DrvEnableDriver - Entry ***\n")); ! 619: ! 620: // Engine Version is passed down so future drivers can support previous ! 621: // engine versions. A next generation driver can support both the old ! 622: // and new engine conventions if told what version of engine it is ! 623: // working with. For the first version the driver does nothing with it. ! 624: ! 625: DISPDBG((2, "S3.DLL!DrvEnableDriver - iEngineVersion: %ld\n", iEngineVersion)); ! 626: ! 627: // Fill in as much as we can. ! 628: ! 629: if (cj >= sizeof(DRVENABLEDATA)) ! 630: pded->pdrvfn = gadrvfn; ! 631: ! 632: if (cj >= (sizeof(ULONG) * 2)) ! 633: pded->c = sizeof(gadrvfn) / sizeof(DRVFN); ! 634: ! 635: // DDI version this driver was targeted for is passed back to engine. ! 636: // Future graphic's engine may break calls down to old driver format. ! 637: ! 638: if (cj >= sizeof(ULONG)) ! 639: pded->iDriverVersion = DDI_DRIVER_VERSION; ! 640: ! 641: return(TRUE); ! 642: } ! 643: ! 644: /******************************Public*Routine******************************\ ! 645: * DrvDisableDriver ! 646: * ! 647: * Tells the driver it is being disabled. Release any resources allocated in ! 648: * DrvEnableDriver. ! 649: * ! 650: \**************************************************************************/ ! 651: ! 652: VOID DrvDisableDriver(VOID) ! 653: { ! 654: return; ! 655: } ! 656: ! 657: /******************************Public*Routine******************************\ ! 658: * DrvEnablePDEV ! 659: * ! 660: * DDI function, Enables the Physical Device. ! 661: * ! 662: * Return Value: device handle to pdev. ! 663: * ! 664: \**************************************************************************/ ! 665: ! 666: DHPDEV DrvEnablePDEV( ! 667: DEVMODEW *pDevmode, // Pointer to DEVMODE ! 668: PWSTR pwszLogAddress, // Logical address ! 669: ULONG cPatterns, // number of patterns ! 670: HSURF *ahsurfPatterns, // return standard patterns ! 671: ULONG cjGdiInfo, // Length of memory pointed to by pGdiInfo ! 672: ULONG *pGdiInfo, // Pointer to GdiInfo structure ! 673: ULONG cjDevInfo, // Length of following PDEVINFO structure ! 674: DEVINFO *pDevInfo, // physical device information structure ! 675: PWSTR pwszDataFile, // DataFile - not used ! 676: PWSTR pwszDeviceName, // DeviceName - not used ! 677: HANDLE hDriver) // Handle to base driver ! 678: { ! 679: GDIINFO GdiInfo; ! 680: DEVINFO DevInfo; ! 681: PPDEV ppdev = (PPDEV) NULL; ! 682: ! 683: UNREFERENCED_PARAMETER(pwszLogAddress); ! 684: UNREFERENCED_PARAMETER(pwszDataFile); ! 685: UNREFERENCED_PARAMETER(pwszDeviceName); ! 686: ! 687: // Allocate a physical device structure. ! 688: ! 689: ppdev = (PPDEV) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(PDEV)); ! 690: ! 691: if (ppdev == (PPDEV) NULL) ! 692: { ! 693: DISPDBG((0, "DISP DrvEnablePDEV failed LocalAlloc\n")); ! 694: EngSetLastError(ERROR_NOT_ENOUGH_MEMORY); ! 695: goto error0; ! 696: } ! 697: ! 698: // Set up pointers in PDEV to temporary structures we build up to return. ! 699: ! 700: ppdev->pGdiInfo = &GdiInfo; ! 701: ppdev->pDevInfo = &DevInfo; ! 702: ! 703: // Save the screen handle in the PDEV. ! 704: ! 705: ppdev->hDriver = hDriver; ! 706: ! 707: // Get the current screen mode information. Set up device caps and devinfo. ! 708: ! 709: if (!bInitPDEV(ppdev, pDevmode)) ! 710: { ! 711: DISPDBG((0, "S3 DrvEnablePDEV failed bGetScreenInfo\n")); ! 712: goto error1; ! 713: } ! 714: ! 715: // Initialize palette information. ! 716: ! 717: if (!bInitPaletteInfo(ppdev)) ! 718: { ! 719: DISPDBG((0, "DISP DrvEnableSurface failed bInitPalette\n")); ! 720: goto error1; ! 721: } ! 722: ! 723: // Initialize device standard patterns. ! 724: ! 725: if (!bInitPatterns(ppdev, min(cPatterns, HS_DDI_MAX))) ! 726: { ! 727: DISPDBG((0, "DISP DrvEnablePDEV failed bInitPatterns\n")); ! 728: goto error2; ! 729: } ! 730: ! 731: // Copy the devinfo into the engine buffer. ! 732: ! 733: memcpy(pDevInfo, ppdev->pDevInfo, min(sizeof(DEVINFO), cjDevInfo)); ! 734: ! 735: // Set the ahsurfPatterns array to handles each of the standard ! 736: // patterns that were just created. ! 737: ! 738: memcpy((PVOID) ahsurfPatterns, ppdev->ahbmPat, ppdev->cPatterns*sizeof(HBITMAP)); ! 739: ! 740: // Set the pdevCaps with GdiInfo we have prepared to the list of caps for this ! 741: // pdev. ! 742: ! 743: memcpy(pGdiInfo, ppdev->pGdiInfo, min(cjGdiInfo, sizeof(GDIINFO))); ! 744: ! 745: // Set NULL into pointers for stack allocated memory. ! 746: ! 747: ppdev->pGdiInfo = (GDIINFO *) NULL; ! 748: ppdev->pDevInfo = (DEVINFO *) NULL; ! 749: ! 750: return((DHPDEV) ppdev); ! 751: ! 752: // Error case for failure. ! 753: ! 754: error2: ! 755: vDisablePatterns(ppdev); ! 756: vDisablePalette(ppdev); ! 757: ! 758: error1: ! 759: LocalFree(ppdev); ! 760: ! 761: error0: ! 762: ! 763: return((DHPDEV) 0); ! 764: } ! 765: ! 766: /******************************Public*Routine******************************\ ! 767: * DrvCompletePDEV ! 768: * ! 769: * Store the HPDEV, the engines handle for this PDEV, in the DHPDEV. ! 770: * ! 771: \**************************************************************************/ ! 772: ! 773: VOID DrvCompletePDEV( ! 774: DHPDEV dhpdev, ! 775: HDEV hdev) ! 776: { ! 777: ((PPDEV) dhpdev)->hdevEng = hdev; ! 778: } ! 779: ! 780: /******************************Public*Routine******************************\ ! 781: * DrvDisablePDEV ! 782: * ! 783: * Release the resources allocated in DrvEnablePDEV. If a surface has been ! 784: * enabled DrvDisableSurface will have already been called. ! 785: * ! 786: \**************************************************************************/ ! 787: ! 788: VOID DrvDisablePDEV( ! 789: DHPDEV dhpdev) ! 790: { ! 791: vDisablePalette((PPDEV) dhpdev); ! 792: vDisablePatterns((PPDEV) dhpdev); ! 793: LocalFree(dhpdev); ! 794: } ! 795: ! 796: /******************************Public*Routine******************************\ ! 797: * DrvEnableSurface ! 798: * ! 799: * Enable the surface for the device. Hook the calls this driver supports. ! 800: * ! 801: * Return: Handle to the surface if successful, 0 for failure. ! 802: * ! 803: \**************************************************************************/ ! 804: ! 805: HSURF DrvEnableSurface( ! 806: DHPDEV dhpdev) ! 807: { ! 808: PPDEV ppdev; ! 809: HSURF hsurf, ! 810: hsurfBm; ! 811: SIZEL sizl; ! 812: ULONG ulBitmapType; ! 813: FLONG flHooks; ! 814: BOOL bRet; ! 815: ! 816: // Create engine bitmap around frame buffer. ! 817: ! 818: ppdev = (PPDEV) dhpdev; ! 819: ! 820: if (!bInitSURF(ppdev, TRUE)) ! 821: { ! 822: DISPDBG((0, "DISP DrvEnableSurface failed bInitSURF\n")); ! 823: return(FALSE); ! 824: } ! 825: ! 826: if (ppdev->ulBitCount == 8) { ! 827: if (!bInit256ColorPalette(ppdev)) { ! 828: DISPDBG((0, "DISP DrvEnableSurface failed to init the 8bpp palette\n")); ! 829: return(FALSE); ! 830: } ! 831: } ! 832: ! 833: sizl.cx = ppdev->cxScreen; ! 834: sizl.cy = ppdev->cyScreen; ! 835: ! 836: // Init the bank manager for the punt system. ! 837: ! 838: bRet = bBankInit(ppdev, TRUE); ! 839: if (bRet == FALSE) ! 840: { ! 841: return (NULL); ! 842: } ! 843: ! 844: // Set all the hooks and create our bitmaps ! 845: ! 846: if (ppdev->ulBitCount == 8) ! 847: { ! 848: ulBitmapType = BMF_8BPP; ! 849: flHooks = HOOKS_BMF8BPP; ! 850: } ! 851: else if (ppdev->ulBitCount == 16) ! 852: { ! 853: ulBitmapType = BMF_16BPP; ! 854: flHooks = HOOKS_BMF16BPP; ! 855: } ! 856: else ! 857: { ! 858: DISPDBG((0,"S3.DLL: ppdev->ulBitCount is invalid\n")); ! 859: } ! 860: ! 861: hsurfBm = (HSURF) EngCreateBitmap(sizl, ! 862: (ULONG) (ppdev->lDeltaScreen), ! 863: (ULONG) (ulBitmapType), ! 864: (FLONG) (((ppdev->lDeltaScreen > 0) ? BMF_TOPDOWN : 0)), ! 865: (PVOID) (ppdev->pjScreen)); ! 866: ! 867: if ((hsurfBm == 0) || (!EngAssociateSurface(hsurfBm, ppdev->hdevEng, 0))) ! 868: { ! 869: DISPDBG((0, "S3.DLL!DrvEnableSurface - failed EngAssociateSurface bitmap\n")); ! 870: EngDeleteSurface(hsurfBm); ! 871: return(NULL); ! 872: } ! 873: ! 874: ppdev->hsurfBm = hsurfBm; ! 875: ! 876: // Note: the engine lock cannot fail, so no error code is checked. ! 877: ! 878: ppdev->pSurfObj = EngLockSurface(hsurfBm); ! 879: ! 880: // BUGBUG Check return code. ! 881: ! 882: sizl.cy = S3BM_HEIGHT; ! 883: ! 884: hsurf = EngCreateSurface((DHSURF) ppdev, sizl); ! 885: if (hsurf == NULL) ! 886: { ! 887: DISPDBG((0, "S3.DLL!DrvEnableSurface - failed EngCreateSurface bitmap\n")); ! 888: EngDeleteSurface(hsurfBm); ! 889: return (NULL); ! 890: } ! 891: ! 892: if (!EngAssociateSurface(hsurf, ppdev->hdevEng, flHooks)) ! 893: { ! 894: DISPDBG((0, "S3.DLL!DrvEnableSurface - failed EngAssociateSurface\n")); ! 895: EngDeleteSurface(hsurfBm); ! 896: EngDeleteSurface(hsurf); ! 897: return(NULL); ! 898: } ! 899: ! 900: ppdev->hsurfEng = hsurf; ! 901: ! 902: // Create a temporary bitmap for the screen to screen punt blits. ! 903: // First, create a surface. ! 904: ! 905: sizl.cx = ppdev->cxMaxRam; ! 906: ! 907: #if defined(_X86_) || defined(i386) ! 908: ! 909: ppdev->psoTemp = NULL; ! 910: ! 911: #else ! 912: ! 913: sizl.cy = ppdev->cyScreen; ! 914: ! 915: hsurfBm = (HSURF) EngCreateBitmap(sizl, ! 916: (ULONG) (ppdev->lDeltaScreen), ! 917: BMF_8BPP, ! 918: BMF_TOPDOWN, ! 919: NULL); ! 920: if (hsurfBm == NULL) ! 921: { ! 922: DISPDBG((0, "S3.DLL!DrvEnableSurface - failed EngCreateBitmap\n")); ! 923: EngDeleteSurface(hsurfBm); ! 924: EngDeleteSurface(hsurf); ! 925: return(NULL); ! 926: } ! 927: ! 928: // Get a pointer to the surface object. ! 929: ! 930: ppdev->psoTemp = EngLockSurface(hsurfBm); ! 931: ! 932: #endif ! 933: ! 934: // These values are here for the strip drawer, they should be removed. ! 935: ! 936: ppdev->iFormat = BMF_PHYSDEVICE; ! 937: ppdev->lNextScan = S3BM_WIDTH; ! 938: ! 939: // Set the shadow clip values. ! 940: ! 941: ppdev->ClipRight = 0; ! 942: ppdev->ClipLeft = 0; ! 943: ppdev->ClipTop = 0; ! 944: ppdev->ClipBottom = 0; ! 945: ! 946: vResetS3Clipping(ppdev); ! 947: ! 948: return(hsurf); ! 949: } ! 950: ! 951: /******************************Public*Routine******************************\ ! 952: * DrvDisableSurface ! 953: * ! 954: * Free resources allocated by DrvEnableSurface. Release the surface. ! 955: * ! 956: \**************************************************************************/ ! 957: ! 958: VOID DrvDisableSurface( ! 959: DHPDEV dhpdev) ! 960: { ! 961: //!!! check and return error. unlock and delete hsurfBM see XGA ! 962: EngDeleteSurface(((PPDEV) dhpdev)->hsurfEng); ! 963: vDisableSURF((PPDEV) dhpdev); ! 964: ((PPDEV) dhpdev)->hsurfEng = (HSURF) 0; ! 965: } ! 966: ! 967: /******************************Public*Routine******************************\ ! 968: * DrvAssertMode ! 969: * ! 970: * This asks the device to reset itself to the mode of the pdev passed in. ! 971: * ! 972: \**************************************************************************/ ! 973: ! 974: VOID DrvAssertMode( ! 975: DHPDEV dhpdev, ! 976: BOOL bEnable) ! 977: { ! 978: PPDEV ppdev = (PPDEV) dhpdev; ! 979: ULONG ulReturn; ! 980: ! 981: #if CATCHIT ! 982: ! 983: if (gLastState == GDI_MODE) ! 984: { ! 985: if (bEnable == TRUE) ! 986: { ! 987: RIP("S3.DLL!DrvAssertMode - Told to go into GDI mode while in GDI mode\n"); ! 988: return; ! 989: } ! 990: } ! 991: else if (gLastState == FULL_SCREEN_MODE) ! 992: { ! 993: if (bEnable == FALSE) ! 994: { ! 995: RIP("S3.DLL!DrvAssertMode - Told to go into Full Screen mode while in Full Screen mode\n"); ! 996: return; ! 997: } ! 998: } ! 999: else ! 1000: { ! 1001: RIP("S3.DLL!DrvAssertMode - Undefine mode\n"); ! 1002: return; ! 1003: } ! 1004: ! 1005: #endif ! 1006: ! 1007: if (bEnable) ! 1008: { ! 1009: gLastState = GDI_MODE; ! 1010: ! 1011: // The screen must be reenabled, reinitialize the device to ! 1012: // a clean state. ! 1013: ! 1014: bInitSURF(ppdev, FALSE); ! 1015: bBankInit(ppdev, FALSE); ! 1016: ! 1017: // Restore the off screen data. This protects the Desktop ! 1018: // from an DOS application that might trash the off screen ! 1019: // memory. ! 1020: ! 1021: ppdev->ClipRight = -1; ! 1022: ppdev->ClipLeft = -1; ! 1023: ppdev->ClipTop = -1; ! 1024: ppdev->ClipBottom = -1; ! 1025: vResetS3Clipping(ppdev); ! 1026: ! 1027: vRestoreOffScreenMemory(ppdev); ! 1028: } ! 1029: else ! 1030: { ! 1031: gLastState = FULL_SCREEN_MODE; ! 1032: ! 1033: // We must give up the display. ! 1034: ! 1035: ppdev->ClipRight = -1; ! 1036: ppdev->ClipLeft = -1; ! 1037: ppdev->ClipTop = -1; ! 1038: ppdev->ClipBottom = -1; ! 1039: vResetS3Clipping(ppdev); ! 1040: vSaveOffScreenMemory(ppdev); ! 1041: ! 1042: // Call the kernel driver to reset the device to a known state. ! 1043: ! 1044: if (!DeviceIoControl(ppdev->hDriver, ! 1045: IOCTL_VIDEO_RESET_DEVICE, ! 1046: NULL, ! 1047: 0, ! 1048: NULL, ! 1049: 0, ! 1050: &ulReturn, ! 1051: NULL)) ! 1052: { ! 1053: DISPDBG((0, "S3.DLL!DrvAssertMode - DrvAssertMode failed IOCTL")); ! 1054: } ! 1055: ! 1056: } ! 1057: ! 1058: return; ! 1059: } ! 1060: ! 1061: ! 1062: /******************************Public*Routine******************************\ ! 1063: * DrvGetModes ! 1064: * ! 1065: * Returns the list of available modes for the device. ! 1066: * ! 1067: \**************************************************************************/ ! 1068: ! 1069: ULONG DrvGetModes( ! 1070: HANDLE hDriver, ! 1071: ULONG cjSize, ! 1072: DEVMODEW *pdm) ! 1073: ! 1074: { ! 1075: ! 1076: DWORD cModes; ! 1077: DWORD cbOutputSize; ! 1078: PVIDEO_MODE_INFORMATION pVideoModeInformation, pVideoTemp; ! 1079: DWORD cOutputModes = cjSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); ! 1080: DWORD cbModeSize; ! 1081: ! 1082: DISPDBG((3, "S3.dll:DrvGetModes\n")); ! 1083: ! 1084: cModes = getAvailableModes(hDriver, ! 1085: (PVIDEO_MODE_INFORMATION *) &pVideoModeInformation, ! 1086: &cbModeSize); ! 1087: ! 1088: ! 1089: if (cModes == 0) ! 1090: { ! 1091: DISPDBG((0, "S3 DISP DrvGetModes failed to get mode information")); ! 1092: return 0; ! 1093: } ! 1094: ! 1095: if (pdm == NULL) ! 1096: { ! 1097: cbOutputSize = cModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); ! 1098: } ! 1099: else ! 1100: { ! 1101: // ! 1102: // Now copy the information for the supported modes back into the output ! 1103: // buffer ! 1104: // ! 1105: ! 1106: cbOutputSize = 0; ! 1107: ! 1108: pVideoTemp = pVideoModeInformation; ! 1109: ! 1110: do ! 1111: { ! 1112: if (pVideoTemp->Length != 0) ! 1113: { ! 1114: if (cOutputModes == 0) ! 1115: { ! 1116: break; ! 1117: } ! 1118: ! 1119: // ! 1120: // Zero the entire structure to start off with. ! 1121: // ! 1122: ! 1123: memset(pdm, 0, sizeof(DEVMODEW)); ! 1124: ! 1125: // ! 1126: // Set the name of the device to the name of the DLL. ! 1127: // ! 1128: ! 1129: memcpy(&(pdm->dmDeviceName), L"s3", sizeof(L"s3")); ! 1130: ! 1131: pdm->dmSpecVersion = DM_SPECVERSION; ! 1132: pdm->dmDriverVersion = DM_SPECVERSION; ! 1133: ! 1134: // ! 1135: // We currently do not support Extra information in the driver ! 1136: // ! 1137: ! 1138: pdm->dmDriverExtra = DRIVER_EXTRA_SIZE; ! 1139: ! 1140: pdm->dmSize = sizeof(DEVMODEW); ! 1141: pdm->dmBitsPerPel = pVideoTemp->NumberOfPlanes * ! 1142: pVideoTemp->BitsPerPlane; ! 1143: pdm->dmPelsWidth = pVideoTemp->VisScreenWidth; ! 1144: pdm->dmPelsHeight = pVideoTemp->VisScreenHeight; ! 1145: pdm->dmDisplayFrequency = pVideoTemp->Frequency; ! 1146: ! 1147: if (pVideoTemp->AttributeFlags & VIDEO_MODE_INTERLACED) ! 1148: { ! 1149: pdm->dmDisplayFlags |= DM_INTERLACED; ! 1150: } ! 1151: ! 1152: // ! 1153: // Go to the next DEVMODE entry in the buffer. ! 1154: // ! 1155: ! 1156: cOutputModes--; ! 1157: ! 1158: pdm = (LPDEVMODEW) ( ((ULONG)pdm) + sizeof(DEVMODEW) + ! 1159: DRIVER_EXTRA_SIZE); ! 1160: ! 1161: cbOutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); ! 1162: ! 1163: } ! 1164: ! 1165: pVideoTemp = (PVIDEO_MODE_INFORMATION) ! 1166: (((PUCHAR)pVideoTemp) + cbModeSize); ! 1167: ! 1168: ! 1169: } while (--cModes); ! 1170: } ! 1171: ! 1172: LocalFree(pVideoModeInformation); ! 1173: ! 1174: return cbOutputSize; ! 1175: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.