enable.c

Go to the documentation of this file.

/*
 * PROJECT:         ReactOS VGA display driver
 * LICENSE:         GPL - See COPYING in the top level directory
 * FILE:            win32ss/drivers/displays/vga/main/enable.c
 * PURPOSE:
 * PROGRAMMERS:
 */
 
#include <vgaddi.h>
 
static BOOL VGAInitialized = FALSE;
 
static DRVFN FuncList[] =
{
    /* Required Display driver fuctions */
    {INDEX_DrvAssertMode, (PFN) DrvAssertMode},
    {INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV},
    {INDEX_DrvCopyBits, (PFN) DrvCopyBits},
    {INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV},
    {INDEX_DrvDisableSurface, (PFN) DrvDisableSurface},
    {INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV},
    {INDEX_DrvEnableSurface, (PFN) DrvEnableSurface},
    {INDEX_DrvGetModes, (PFN) DrvGetModes},
    {INDEX_DrvLineTo, (PFN) DrvLineTo},
    {INDEX_DrvPaint, (PFN) DrvPaint},
    {INDEX_DrvBitBlt, (PFN) DrvBitBlt},
    {INDEX_DrvTransparentBlt, (PFN) DrvTransparentBlt},
    {INDEX_DrvMovePointer, (PFN) DrvMovePointer},
    {INDEX_DrvSetPointerShape, (PFN) DrvSetPointerShape},
 
#if 0
    /* Optional Display driver functions */
    {INDEX_, },
    {INDEX_DescribePixelFormat, (PFN) VGADDIDescribePixelFormat},
    {INDEX_DrvDitherColor, (PFN) VGADDIDitherColor},
    {INDEX_DrvFillPath, (PFN) VGADDIFillPath},
    {INDEX_DrvGetTrueTypeFile, (PFN) VGADDIGetTrueTypeFile},
    {INDEX_DrvLoadFontFile, (PFN) VGADDILoadFontFile},
    {INDEX_DrvQueryFont, (PFN) VGADDIQueryFont},
    {INDEX_DrvQueryFontCaps, (PFN) VGADDIQueryFontCaps},
    {INDEX_DrvQueryFontData, (PFN) VGADDIQueryFontData},
    {INDEX_DrvQueryFontFile, (PFN) VGADDIQueryFontFile},
    {INDEX_DrvQueryFontTree, (PFN) VGADDIQueryFontTree},
    {INDEX_DrvQueryTrueTypeOutline, (PFN) VGADDIQueryTrueTypeOutline},
    {INDEX_DrvQueryTrueTypeTable, (PFN) VGADDIQueryTrueTypeTable},
    {INDEX_DrvRealizeBrush, (PFN) VGADDIRealizeBrush},
    {INDEX_DrvResetPDEV, (PFN) VGADDIResetPDEV},
    {INDEX_DrvSetPalette, (PFN) VGADDISetPalette},
    {INDEX_DrvSetPixelFormat, (PFN) VGADDISetPixelFormat},
    {INDEX_DrvStretchBlt, (PFN) VGADDIStretchBlt},
    {INDEX_DrvStrokePath, (PFN) VGADDIStrokePath},
    {INDEX_DrvSwapBuffers, (PFN) VGADDISwapBuffers},
    {INDEX_DrvTextOut, (PFN) VGADDITextOut},
    {INDEX_DrvUnloadFontFile, (PFN) VGADDIUnloadFontFile},
#endif
};
 
static GDIINFO gaulCap = {
    GDI_DRIVER_VERSION,    // ulVersion
    DT_RASDISPLAY,         // ulTechnology
    0,                     // ulHorzSize
    0,                     // ulVertSize
    0,                     // ulHorzRes (filled in at initialization)
    0,                     // ulVertRes (filled in at initialization)
    4,                     // cBitsPixel
    1,                     // cPlanes
    16,                    // ulNumColors
    0,                     // flRaster (DDI reserved field)
 
    96,                    // ulLogPixelsX (must be set to 96 according to MSDN)
    96,                    // ulLogPixelsY (must be set to 96 according to MSDN)
 
    TC_RA_ABLE | TC_SCROLLBLT,  // flTextCaps
 
    6,                     // ulDACRed
    6,                     // ulDACGreen
    6,                     // ulDACBlue
 
    0x0024,                // ulAspectX  (one-to-one aspect ratio)
    0x0024,                // ulAspectY
    0x0033,                // ulAspectXY
 
    1,                     // xStyleStep
    1,                     // yStyleSte;
    3,                     // denStyleStep
 
    { 0, 0 },              // ptlPhysOffset
    { 0, 0 },              // szlPhysSize
 
    0,                     // ulNumPalReg (win3.1 16 color drivers say 0 too)
 
// These fields are for halftone initialization.
 
    {                                         // ciDevice, ColorInfo
        { 6700, 3300, 0 },                      // Red
        { 2100, 7100, 0 },                      // Green
        { 1400,  800, 0 },                      // Blue
        { 1750, 3950, 0 },                      // Cyan
        { 4050, 2050, 0 },                      // Magenta
        { 4400, 5200, 0 },                      // Yellow
        { 3127, 3290, 0 },                      // AlignmentWhite
        20000,                                  // RedGamma
        20000,                                  // GreenGamma
        20000,                                  // BlueGamma
        0, 0, 0, 0, 0, 0
    },
 
    0,                                         // ulDevicePelsDPI
    PRIMARY_ORDER_CBA,                         // ulPrimaryOrder
    HT_PATSIZE_4x4_M,                          // ulHTPatternSize
    HT_FORMAT_4BPP_IRGB,                       // ulHTOutputFormat
    HT_FLAG_ADDITIVE_PRIMS,                    // flHTFlags
 
    0,                                         // ulVRefresh
    8,                                         // ulBltAlignment
    0,                                         // ulPanningHorzRes
    0,                                         // ulPanningVertRes
 
    0,                                         // xPanningAlignment
    0,                                         // yPanningAlignment
    0,                                         // cxHTPat
    0,                                         // cyHTPat
    NULL,                                      // pHTPatA
    NULL,                                      // pHTPatB
    NULL,                                      // pHTPatC
    0,                                         // flShadeBlend
    0,                                         // ulPhysicalPixelCharacteristics
    0                                          // ulPhysicalPixelGamma
};
 
// Palette for VGA
 
typedef struct _VGALOGPALETTE
{
    USHORT ident;
    USHORT NumEntries;
    PALETTEENTRY PaletteEntry[16];
} VGALOGPALETTE;
 
const VGALOGPALETTE VGApalette =
{
 
    0x400,  // driver version
    16,     // num entries
    {
        { 0x00, 0x00, 0x00, 0x00 }, // 0
        { 0x80, 0x00, 0x00, 0x00 }, // 1
        { 0x00, 0x80, 0x00, 0x00 }, // 2
        { 0x80, 0x80, 0x00, 0x00 }, // 3
        { 0x00, 0x00, 0x80, 0x00 }, // 4
        { 0x80, 0x00, 0x80, 0x00 }, // 5
        { 0x00, 0x80, 0x80, 0x00 }, // 6
        { 0x80, 0x80, 0x80, 0x00 }, // 7
        { 0xc0, 0xc0, 0xc0, 0x00 }, // 8
        { 0xff, 0x00, 0x00, 0x00 }, // 9
        { 0x00, 0xff, 0x00, 0x00 }, // 10
        { 0xff, 0xff, 0x00, 0x00 }, // 11
        { 0x00, 0x00, 0xff, 0x00 }, // 12
        { 0xff, 0x00, 0xff, 0x00 }, // 13
        { 0x00, 0xff, 0xff, 0x00 }, // 14
        { 0xff, 0xff, 0xff, 0x00 } // 15
    }
};
 
// Devinfo structure passed back to the engine in DrvEnablePDEV
 
#define SYSTM_LOGFONT {16,7,0,0,700,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,VARIABLE_PITCH | FF_DONTCARE, L"System"}
#define HELVE_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,VARIABLE_PITCH | FF_DONTCARE, L"MS Sans Serif"}
#define COURI_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,FIXED_PITCH | FF_DONTCARE, L"Courier"}
 
DEVINFO devinfoVGA =
{
    (GCAPS_OPAQUERECT | GCAPS_HORIZSTRIKE | GCAPS_ALTERNATEFILL | GCAPS_MONO_DITHER | GCAPS_COLOR_DITHER |
     GCAPS_WINDINGFILL | GCAPS_DITHERONREALIZE
    ),       // Graphics capabilities
 
    SYSTM_LOGFONT,  // Default font description
    HELVE_LOGFONT,  // ANSI variable font description
    COURI_LOGFONT,  // ANSI fixed font description
    0,              // Count of device fonts
    BMF_4BPP,       // preferred DIB format
    8,              // Width of color dither
    8,              // Height of color dither
    NULL,           // Default palette to use for this device
    0               // flGraphicsCaps2
};
 
BOOL APIENTRY
DrvEnableDriver(IN ULONG EngineVersion,
                IN ULONG SizeOfDED,
                OUT PDRVENABLEDATA DriveEnableData)
{
    DPRINT("DrvEnableDriver called...\n");
 
    vgaPreCalc();
 
    VGADDI_InitializeOffScreenMem((SCREEN_X * SCREEN_Y) >> 3, 65536 - ((SCREEN_X * SCREEN_Y) >> 3));
 
    DriveEnableData->pdrvfn = FuncList;
    DriveEnableData->c = sizeof(FuncList) / sizeof(DRVFN);
    DriveEnableData->iDriverVersion = DDI_DRIVER_VERSION_NT4;
 
    return  TRUE;
}
 
//    DrvDisableDriver
//  DESCRIPTION:
//    This function is called by the KMGDI at exit.  It should cleanup.
//  ARGUMENTS:
//    NONE
//  RETURNS:
//    NONE
 
VOID APIENTRY
DrvDisableDriver(VOID)
{
    return;
}
 
//  -----------------------------------------------  Driver Implementation
 
 
//    DrvEnablePDEV
//  DESCRIPTION:
//    This function is called after DrvEnableDriver to get information
//    about the mode that is to be used.  This function just returns
//    information, and should not yet initialize the mode.
//  ARGUMENTS:
//    IN DEVMODEW *  DM            Describes the mode requested
//    IN LPWSTR      LogAddress
//    IN ULONG       PatternCount  number of patterns expected
//    OUT HSURF *    SurfPatterns  array to contain pattern handles
//    IN ULONG       GDIInfoSize   the size of the GDIInfo object passed in
//    OUT ULONG *    GDIInfo       GDI Info object
//    IN ULONG       DevInfoSize   the size of the DevInfo object passed in
//    OUT ULONG *    DevInfo       Device Info object
//    IN LPWSTR      DevDataFile   ignore
//    IN LPWSTR      DeviceName    Device name
//    IN HANDLE      Driver        handle to KM driver
//  RETURNS:
//    DHPDEV  a handle to a DPev object
 
DHPDEV APIENTRY
DrvEnablePDEV(IN DEVMODEW *DM,
              IN LPWSTR LogAddress,
              IN ULONG PatternCount,
              OUT HSURF *SurfPatterns,
              IN ULONG GDIInfoSize,
              OUT ULONG *GDIInfo,
              IN ULONG DevInfoSize,
              OUT DEVINFO *DevInfo,
              IN HDEV Dev,
              IN LPWSTR DeviceName,
              IN HANDLE Driver)
{
    PPDEV  PDev;
 
    PDev = EngAllocMem(FL_ZERO_MEMORY, sizeof(PDEV), ALLOC_TAG);
    if (PDev == NULL)
    {
        DPRINT1("EngAllocMem failed for PDEV\n");
        return NULL;
    }
    PDev->KMDriver = Driver;
    DPRINT( "PDev: %x, Driver: %x\n", PDev, PDev->KMDriver );
 
    gaulCap.ulHorzRes = SCREEN_X;
    gaulCap.ulVertRes = SCREEN_Y;
    if (sizeof(GDIINFO) < GDIInfoSize)
        GDIInfoSize = sizeof(GDIINFO);
    memcpy(GDIInfo, &gaulCap, GDIInfoSize);
    DM->dmBitsPerPel = gaulCap.cBitsPixel * gaulCap.cPlanes;
    DM->dmPelsWidth = gaulCap.ulHorzRes;
    DM->dmPelsHeight = gaulCap.ulVertRes;
 
    devinfoVGA.hpalDefault = EngCreatePalette(PAL_INDEXED, 16, (ULONG *) VGApalette.PaletteEntry, 0, 0, 0);
    if (sizeof(DEVINFO) < DevInfoSize)
        DevInfoSize = sizeof(DEVINFO);
    memcpy(DevInfo, &devinfoVGA, DevInfoSize);
 
    return (DHPDEV) PDev;
}
 
//    DrvCompletePDEV
//  DESCRIPTION
//    Called after initialization of PDEV is complete.  Supplies
//    a reference to the GDI handle for the PDEV.
 
VOID APIENTRY
DrvCompletePDEV(IN DHPDEV PDev,
                IN HDEV Dev)
{
    ((PPDEV) PDev)->GDIDevHandle = Dev; // Handle to the DC
}
 
BOOL APIENTRY
DrvAssertMode(IN DHPDEV DPev,
              IN BOOL Enable)
{
    PPDEV ppdev = (PPDEV)DPev;
    ULONG returnedDataLength;
 
    if (Enable)
    {
        /* Reenable our graphics mode */
        if (!InitPointer(ppdev))
        {
            /* Failed to set pointer */
            return FALSE;
        }
 
        if (!VGAInitialized)
        {
            if (!InitVGA(ppdev, FALSE))
            {
                /* Failed to initialize the VGA */
                return FALSE;
            }
            VGAInitialized = TRUE;
      }
    }
    else
    {
        /* Go back to last known mode */
        DPRINT("ppdev: %p, KMDriver: %p\n", ppdev, ppdev->KMDriver);
        if (EngDeviceIoControl(ppdev->KMDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &returnedDataLength))
        {
            /* Failed to go back to mode */
            return FALSE;
        }
        VGAInitialized = FALSE;
    }
    return TRUE;
}
 
VOID APIENTRY
DrvDisablePDEV(IN DHPDEV PDev)
{
    PPDEV ppdev = (PPDEV)PDev;
 
    /*  EngDeletePalette(devinfoVGA.hpalDefault); */
    if (ppdev->pjPreallocSSBBuffer)
        EngFreeMem(ppdev->pjPreallocSSBBuffer);
 
    if (ppdev->pucDIB4ToVGAConvBuffer)
        EngFreeMem(ppdev->pucDIB4ToVGAConvBuffer);
 
    DPRINT("Freeing PDEV\n");
    EngFreeMem(PDev);
}
 
VOID APIENTRY
DrvDisableSurface(IN DHPDEV PDev)
{
    PPDEV ppdev = (PPDEV)PDev;
    PDEVSURF pdsurf = ppdev->AssociatedSurf;
 
    DPRINT("KMDriver: %x\n", ppdev->KMDriver);
    DeinitVGA(ppdev);
    /* EngFreeMem(pdsurf->BankSelectInfo); */
 
    if (pdsurf->BankInfo != NULL)
        EngFreeMem(pdsurf->BankInfo);
    if (pdsurf->BankInfo2RW != NULL)
        EngFreeMem(pdsurf->BankInfo2RW);
    if (pdsurf->BankBufferPlane0 != NULL)
        EngFreeMem(pdsurf->BankBufferPlane0);
    if (ppdev->pPointerAttributes != NULL)
        EngFreeMem(ppdev->pPointerAttributes);
 
    /* free any pending saved screen bit blocks */
#if 0
    pSSB = pdsurf->ssbList;
    while (pSSB != NULL)
    {
        /* Point to the next saved screen bits block */
        pSSBNext = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB;
 
        /* Free the current block */
        EngFreeMem(pSSB);
        pSSB = pSSBNext;
    }
#endif
    EngDeleteSurface((HSURF) ppdev->SurfHandle);
    /* EngFreeMem(pdsurf); */ /* free the surface */
}
 
static VOID
InitSavedBits(IN PPDEV ppdev)
{
    if (!(ppdev->fl & DRIVER_OFFSCREEN_REFRESHED))
        return;
 
    /* set up rect to right of visible screen */
    ppdev->SavedBitsRight.left   = ppdev->sizeSurf.cx;
    ppdev->SavedBitsRight.top    = 0;
    ppdev->SavedBitsRight.right  = ppdev->sizeMem.cx - PLANAR_PELS_PER_CPU_ADDRESS;
    ppdev->SavedBitsRight.bottom = ppdev->sizeSurf.cy;
 
    if ((ppdev->SavedBitsRight.right <= ppdev->SavedBitsRight.left) ||
        (ppdev->SavedBitsRight.bottom <= ppdev->SavedBitsRight.top))
    {
        ppdev->SavedBitsRight.left   = 0;
        ppdev->SavedBitsRight.top    = 0;
        ppdev->SavedBitsRight.right  = 0;
        ppdev->SavedBitsRight.bottom = 0;
    }
 
    /* set up rect below visible screen */
    ppdev->SavedBitsBottom.left   = 0;
    ppdev->SavedBitsBottom.top    = ppdev->sizeSurf.cy;
    ppdev->SavedBitsBottom.right  = ppdev->sizeMem.cx - PLANAR_PELS_PER_CPU_ADDRESS;
    ppdev->SavedBitsBottom.bottom = ppdev->sizeMem.cy - ppdev->NumScansUsedByPointer;
 
    if ((ppdev->SavedBitsBottom.right <= ppdev->SavedBitsBottom.left) ||
        (ppdev->SavedBitsBottom.bottom <= ppdev->SavedBitsBottom.top))
    {
        ppdev->SavedBitsBottom.left   = 0;
        ppdev->SavedBitsBottom.top    = 0;
        ppdev->SavedBitsBottom.right  = 0;
        ppdev->SavedBitsBottom.bottom = 0;
    }
 
    ppdev->BitsSaved = FALSE;
}
 
HSURF APIENTRY
DrvEnableSurface(IN DHPDEV PDev)
{
    PPDEV ppdev = (PPDEV)PDev;
    PDEVSURF pdsurf;
    DHSURF dhsurf;
    HSURF hsurf;
 
    DPRINT("DrvEnableSurface() called\n");
 
    /* Initialize the VGA */
    if (!VGAInitialized)
    {
        if (!InitVGA(ppdev, TRUE))
            goto error_done;
        VGAInitialized = TRUE;
    }
 
    /* dhsurf is of type DEVSURF, which is the drivers specialized surface type */
    dhsurf = (DHSURF)EngAllocMem(0, sizeof(DEVSURF), ALLOC_TAG);
    if (dhsurf == NULL)
        goto error_done;
 
    pdsurf = (PDEVSURF) dhsurf;
    pdsurf->ident         = DEVSURF_IDENT;
    pdsurf->flSurf        = 0;
    pdsurf->Format        = BMF_PHYSDEVICE;
    pdsurf->jReserved1    = 0;
    pdsurf->jReserved2    = 0;
    pdsurf->ppdev         = ppdev;
    pdsurf->sizeSurf.cx   = ppdev->sizeSurf.cx;
    pdsurf->sizeSurf.cy   = ppdev->sizeSurf.cy;
    pdsurf->NextPlane     = 0;
    pdsurf->Scan0         = ppdev->fbScreen;
    pdsurf->BitmapStart   = ppdev->fbScreen;
    pdsurf->StartBmp      = ppdev->fbScreen;
    pdsurf->BankInfo      = NULL;
    pdsurf->BankInfo2RW   = NULL;
    pdsurf->BankBufferPlane0 = NULL;
 
/*    pdsurf->Conv          = &ConvertBuffer[0]; */
 
    if (!InitPointer(ppdev))
    {
        DPRINT1("DrvEnablePDEV failed bInitPointer\n");
        goto error_clean;
     }
 
/*    if (!SetUpBanking(pdsurf, ppdev))
    {
        DPRINT1("DrvEnablePDEV failed SetUpBanking\n");
        goto error_clean;
    } BANKING CODE UNIMPLEMENTED */
 
    if ((hsurf = EngCreateDeviceSurface(dhsurf, ppdev->sizeSurf, BMF_4BPP)) ==
        NULL)
    {
        /* Call to EngCreateDeviceSurface failed */
        DPRINT("EngCreateDeviceSurface call failed\n");
        goto error_clean;
    }
 
    InitSavedBits(ppdev);
 
    if (EngAssociateSurface(hsurf, ppdev->GDIDevHandle, HOOK_BITBLT | HOOK_PAINT | HOOK_LINETO | HOOK_COPYBITS |
        HOOK_TRANSPARENTBLT))
    {
        DPRINT("Successfully associated surface\n");
        ppdev->SurfHandle = hsurf;
        ppdev->AssociatedSurf = pdsurf;
 
       /* Set up an empty saved screen block list */
       pdsurf->ssbList = NULL;
 
      return hsurf;
    }
    DPRINT("EngAssociateSurface() failed\n");
    EngDeleteSurface(hsurf);
 
error_clean:
    EngFreeMem(dhsurf);
 
error_done:
    return NULL;
}
 
ULONG APIENTRY
DrvGetModes(IN HANDLE Driver,
            IN ULONG DataSize,
            OUT PDEVMODEW DM)
{
    DWORD NumModes;
    DWORD ModeSize;
    DWORD OutputSize;
    DWORD OutputModes = DataSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
    PVIDEO_MODE_INFORMATION VideoModeInformation, VideoTemp;
 
    NumModes = getAvailableModes(Driver,
                                 (PVIDEO_MODE_INFORMATION *) &VideoModeInformation,
                                 &ModeSize);
 
    if (NumModes == 0)
        return 0;
 
    if (DM == NULL)
    {
        OutputSize = NumModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
    }
    else
    {
        OutputSize=0;
        VideoTemp = VideoModeInformation;
 
        do
        {
            if (VideoTemp->Length != 0)
            {
                if (OutputModes == 0)
                    break;
 
                memset(DM, 0, sizeof(DEVMODEW));
                memcpy(DM->dmDeviceName, DLL_NAME, sizeof(DLL_NAME));
 
                DM->dmSpecVersion      = DM_SPECVERSION;
                DM->dmDriverVersion    = DM_SPECVERSION;
                DM->dmSize             = sizeof(DEVMODEW);
                DM->dmDriverExtra      = DRIVER_EXTRA_SIZE;
                DM->dmBitsPerPel       = VideoTemp->NumberOfPlanes *
                                         VideoTemp->BitsPerPlane;
                DM->dmPelsWidth        = VideoTemp->VisScreenWidth;
                DM->dmPelsHeight       = VideoTemp->VisScreenHeight;
                DM->dmDisplayFrequency = VideoTemp->Frequency;
                DM->dmDisplayFlags     = 0;
 
                DM->dmFields           = DM_BITSPERPEL       |
                                         DM_PELSWIDTH        |
                                         DM_PELSHEIGHT       |
                                         DM_DISPLAYFREQUENCY |
                                         DM_DISPLAYFLAGS     ;
 
                /* next DEVMODE entry */
                OutputModes--;
 
                DM = (PDEVMODEW) ( ((ULONG_PTR)DM) + sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
 
                OutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
            }
 
            VideoTemp = (PVIDEO_MODE_INFORMATION)(((PUCHAR)VideoTemp) + ModeSize);
 
        } while (--NumModes);
    }
    return OutputSize;
}
 
ULONG DbgPrint(PCCH Format,...)
{
    va_list ap;
    va_start(ap, Format);
    EngDebugPrint("VGADDI", (PCHAR)Format, ap);
    va_end(ap);
    return 0;
}
 
/* EOF */