reactos/drivers/video/displays/framebufacc/surface.c

327 lines
8.1 KiB
C
Raw Normal View History

/*
* ReactOS Generic Framebuffer acclations display driver
*
* Copyright (C) 2004 Filip Navara
* Copyright (C) 2007 Magnus Olsen
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "framebufacc.h"
BOOL
InitSurface(PPDEV ppdev,
BOOL bForcemapping)
{
VIDEO_MEMORY VideoMemory;
VIDEO_MEMORY_INFORMATION VideoMemoryInfo;
ULONG returnedDataLength;
ULONG RemappingNeeded = 0;
ULONG PointerMaxWidth = 0;
ULONG PointerMaxHeight = 0;
/*
* Set video mode of our adapter.
*/
if (EngDeviceIoControl(ppdev->hDriver,
IOCTL_VIDEO_SET_CURRENT_MODE,
&(ppdev->ModeIndex),
sizeof(ULONG),
&RemappingNeeded,
sizeof(ULONG),
&returnedDataLength))
{
return FALSE;
}
/* Check if mapping is need it */
if ((!bForcemapping) &&
(!RemappingNeeded))
{
return TRUE;
}
/*
* Map the framebuffer into our memory.
*/
VideoMemory.RequestedVirtualAddress = NULL;
if (EngDeviceIoControl(ppdev->hDriver, IOCTL_VIDEO_MAP_VIDEO_MEMORY,
&VideoMemory, sizeof(VIDEO_MEMORY),
&VideoMemoryInfo, sizeof(VIDEO_MEMORY_INFORMATION),
&returnedDataLength))
{
return FALSE;
}
/*
* Save the real video memory
*/
ppdev->pRealVideoMem = VideoMemoryInfo.FrameBufferBase;
ppdev->VideoMemSize = VideoMemoryInfo.VideoRamLength;
/*
* Video memory cached
*
* We maby should only ask max 8MB as cached ?, think of the video ram length is 256MB
*/
ppdev->pVideoMemCache = NULL;
#ifdef EXPERIMENTAL_ACC_SUPPORT
ppdev->pVideoMemCache = EngAllocMem(0, (ULONG)VideoMemoryInfo.VideoRamLength, ALLOC_TAG);
if (ppdev->pVideoMemCache == NULL)
{
/* cached off for no avail system memory */
ppdev->ScreenPtr = VideoMemoryInfo.FrameBufferBase;
}
else
#endif
{
/* cached on, system memory is avail */
ppdev->ScreenPtr = ppdev->pRealVideoMem;
}
/* hw mouse pointer support */
PointerMaxHeight = ppdev->PointerCapabilities.MaxHeight;
PointerMaxWidth = ppdev->PointerCapabilities.MaxWidth * sizeof(ULONG);
if (ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER)
{
PointerMaxWidth = (ppdev->PointerCapabilities.MaxWidth + 7) / 8;
}
ppdev->PointerAttributesSize = sizeof(VIDEO_POINTER_ATTRIBUTES) + ((sizeof(UCHAR) * PointerMaxWidth * PointerMaxHeight) << 1);
ppdev->pPointerAttributes = EngAllocMem(0, ppdev->PointerAttributesSize, ALLOC_TAG);
if (ppdev->pPointerAttributes != NULL)
{
ppdev->pPointerAttributes->Flags = ppdev->PointerCapabilities.Flags;
ppdev->pPointerAttributes->WidthInBytes = PointerMaxWidth;
ppdev->pPointerAttributes->Width = ppdev->PointerCapabilities.MaxWidth;
ppdev->pPointerAttributes->Height = PointerMaxHeight;
ppdev->pPointerAttributes->Column = 0;
ppdev->pPointerAttributes->Row = 0;
ppdev->pPointerAttributes->Enable = 0;
}
else
{
/* no hw mouse was avail */
ppdev->PointerAttributesSize = 0;
}
return TRUE;
}
/*
* DrvEnableSurface
*
* Create engine bitmap around frame buffer and set the video mode requested
* when PDEV was initialized.
*
* Status
* @implemented
*/
HSURF APIENTRY
DrvEnableSurface(
IN DHPDEV dhpdev)
{
PPDEV ppdev = (PPDEV)dhpdev;
HSURF hSurface;
ULONG BitmapType;
SIZEL ScreenSize;
/* Setup surface and force the mapping */
if (!InitSurface(ppdev, TRUE))
{
return FALSE;
}
/* Rest the desktop vitual position */
ppdev->ScreenOffsetXY.x = 0;
ppdev->ScreenOffsetXY.y = 0;
switch (ppdev->BitsPerPixel)
{
case 8:
IntSetPalette(dhpdev, ppdev->PaletteEntries, 0, 256);
BitmapType = BMF_8BPP;
break;
case 16:
BitmapType = BMF_16BPP;
break;
case 24:
BitmapType = BMF_24BPP;
break;
case 32:
BitmapType = BMF_32BPP;
break;
default:
return FALSE;
}
ppdev->iDitherFormat = BitmapType;
ScreenSize.cx = ppdev->ScreenWidth;
ScreenSize.cy = ppdev->ScreenHeight;
hSurface = (HSURF)EngCreateBitmap(ScreenSize, ppdev->ScreenDelta, BitmapType,
(ppdev->ScreenDelta > 0) ? BMF_TOPDOWN : 0,
ppdev->ScreenPtr);
if (hSurface == NULL)
{
return FALSE;
}
/* Which api we hooking to */
ppdev->dwHooks = HOOK_BITBLT | HOOK_COPYBITS | HOOK_FILLPATH | HOOK_TEXTOUT | HOOK_STROKEPATH | HOOK_LINETO ;
/*
* Associate the surface with our device.
*/
if (!EngAssociateSurface(hSurface, ppdev->hDevEng, ppdev->dwHooks))
{
EngDeleteSurface(hSurface);
return FALSE;
}
ppdev->hSurfEng = hSurface;
return hSurface;
}
/*
* DrvDisableSurface
*
* Used by GDI to notify a driver that the surface created by DrvEnableSurface
* for the current device is no longer needed.
*
* Status
* @implemented
*/
VOID APIENTRY
DrvDisableSurface(
IN DHPDEV dhpdev)
{
DWORD ulTemp;
VIDEO_MEMORY VideoMemory;
PPDEV ppdev = (PPDEV)dhpdev;
EngDeleteSurface(ppdev->hSurfEng);
ppdev->hSurfEng = NULL;
/* Free the video memory cache */
if (ppdev->pVideoMemCache)
{
EngFreeMem(ppdev->pVideoMemCache);
}
/*
* Unmap the framebuffer.
*/
VideoMemory.RequestedVirtualAddress = ppdev->pRealVideoMem;
EngDeviceIoControl(((PPDEV)dhpdev)->hDriver, IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
&VideoMemory, sizeof(VIDEO_MEMORY), NULL, 0, &ulTemp);
ppdev->pRealVideoMem = NULL;
ppdev->pVideoMemCache = NULL;
}
/*
* DrvAssertMode
*
* Sets the mode of the specified physical device to either the mode specified
* when the PDEV was initialized or to the default mode of the hardware.
*
* Status
* @implemented
*/
BOOL APIENTRY
DrvAssertMode(
IN DHPDEV dhpdev,
IN BOOL bEnable)
{
PPDEV ppdev = (PPDEV)dhpdev;
ULONG ulTemp;
BOOLEAN Result = TRUE;
if (bEnable)
{
PVOID pRealVideoMem = ppdev->pRealVideoMem;
/* Setup surface and remapping if it need it */
if (!InitSurface(ppdev, FALSE))
{
Result = FALSE;
}
else
{
/* Check if we got same surface or not */
if (pRealVideoMem != ppdev->pRealVideoMem)
{
PVOID pVideoMem= NULL;
if (ppdev->pVideoMemCache == NULL)
{
pVideoMem = ppdev->pRealVideoMem;
}
else
{
pVideoMem = ppdev->pVideoMemCache;
}
Result = !EngModifySurface(ppdev->hSurfEng, ppdev->hDevEng,
ppdev->dwHooks | HOOK_SYNCHRONIZE,
0, (DHSURF)ppdev, pVideoMem,
ppdev->ScreenDelta, NULL);
}
/* if the pRealVideoMem == ppdev->pRealVideoMem are
* the Result is then TRUE
*/
}
}
else
{
/*
* Call the miniport driver to reset the device to a known state.
*/
Result = !EngDeviceIoControl(ppdev->hDriver, IOCTL_VIDEO_RESET_DEVICE,
NULL, 0, NULL, 0, &ulTemp);
}
return Result;
}