DevVGA_VDMA.cpp revision 5cf075f1173d07b89c26db295070415dffc6109d
/** @file
* Video DMA (VDMA) support.
*/
/*
* Copyright (C) 2006-2009 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#include <VBox/VBoxVideo.h>
#include <iprt/semaphore.h>
#include "DevVGA.h"
#include "HGSMI/SHGSMIHost.h"
#include "HGSMI/HGSMIHostHlp.h"
typedef enum
{
typedef struct VBOXVDMAPIPE
{
/* critical section for accessing pipe properties */
/* true iff the other end needs Event notification */
bool bNeedNotify;
typedef enum
{
typedef struct VBOXVDMAPIPE_CMD_BODY
{
union
{
void *pvCmd;
} u;
typedef struct VBOXVDMAPIPE_CMD
{
#define VBOXVDMAPIPE_CMD_FROM_ENTRY(_pE) ( (PVBOXVDMAPIPE_CMD)((uint8_t *)(_pE) - RT_OFFSETOF(VBOXVDMAPIPE_CMD, Entry)) )
typedef struct VBOXVDMAPIPE_CMD_POOL
{
typedef struct VBOXVDMAHOST
{
bool bEnabled;
#ifdef VBOX_WITH_CRHGSMI
typedef DECLCALLBACK(void) FNVBOXVDMACRCTL_CALLBACK(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, void* pvContext);
typedef struct VBOXVDMACMD_CHROMIUM_CTL_PRIVATE
{
void *pvCompletion;
#define VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(_p) ((PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CTL_PRIVATE, Cmd)))
static PVBOXVDMACMD_CHROMIUM_CTL vboxVDMACrCtlCreate(VBOXVDMACMD_CHROMIUM_CTL_TYPE enmCmd, uint32_t cbCmd)
{
PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pHdr = (PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE)RTMemAllocZ(cbCmd + RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CTL_PRIVATE, Cmd));
if (pHdr)
{
}
return NULL;
}
{
if(!cRefs)
{
}
}
{
}
{
}
static DECLCALLBACK(void) vboxVDMACrCtlCbSetEvent(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, void* pvContext)
{
}
static DECLCALLBACK(void) vboxVDMACrCtlCbReleaseCmd(PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, void* pvContext)
{
}
static int vboxVDMACrCtlPostAsync (PVGASTATE pVGAState, PVBOXVDMACMD_CHROMIUM_CTL pCmd, PFNVBOXVDMACRCTL_CALLBACK pfnCompletion, void *pvCompletion)
{
{
return VINF_SUCCESS;
}
#ifdef DEBUG_misha
Assert(0);
#endif
return VERR_NOT_SUPPORTED;
}
{
if(RT_SUCCESS(rc))
{
#ifdef DEBUG_misha
#endif
if (RT_SUCCESS(rc))
{
if(RT_SUCCESS(rc))
{
}
}
else
{
/* the command is completed */
}
}
return rc;
}
{
PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP pCmd = (PVBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP)vboxVDMACrCtlCreate(
VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP, sizeof (*pCmd));
if (pCmd)
{
#ifdef DEBUG_misha
#endif
#if 0
if (RT_SUCCESS(rc))
{
}
#endif
return rc;
}
return VERR_NO_MEMORY;
}
/* check if this is external cmd to be passed to chromium backend */
{
else
if (pDmaCmd)
{
if (cbCmd >= VBOXVDMACMD_HEADER_SIZE())
{
{
{
return true;
}
else
{
Assert(0);
}
// uint32_t cBufs = pCrCmd->cBuffers;
// for (uint32_t i = 0; i < cBufs; ++i)
// {
// PVBOXVDMACMD_CHROMIUM_BUFFER pBuf = &pCrCmd->aBuffers[i];
// void *pvBuffer = pvRam + pBuf->offBuffer;
// uint32_t cbBuffer = pBuf->cbBuffer;
// }
}
}
}
return false;
}
int vboxVDMACrHgsmiCommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, int rc)
{
return rc;
}
int vboxVDMACrHgsmiControlCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, int rc)
{
if (pCmdPrivate->pfnCompletion)
{
}
return VINF_SUCCESS;
}
#endif
/* to simplify things and to avoid extra backend if modifications we assume the VBOXVDMA_RECTL is the same as VBVACMDHDR */
static int vboxVDMANotifyPrimaryUpdate (PVGASTATE pVGAState, unsigned uScreenId, const VBOXVDMA_RECTL * pRectl)
{
/* Updates the rectangle and sends the command to the VRDP server. */
sizeof (VBOXVDMA_RECTL));
return VINF_SUCCESS;
}
{
/* we do not support color conversion */
/* we do not support stretching */
return VERR_INVALID_FUNCTION;
{
}
else
{
uint32_t offDstLineEnd = ((pDstRectl->left * pDstDesc->bpp + 7) >> 3) + ((pDstDesc->bpp * pDstRectl->width + 7) >> 3);
uint32_t offSrcLineEnd = ((pSrcRectl->left * pSrcDesc->bpp + 7) >> 3) + ((pSrcDesc->bpp * pSrcRectl->width + 7) >> 3);
for (uint32_t i = 0; ; ++i)
{
break;
pvDstStart += cbDstSkip;
pvSrcStart += cbSrcSkip;
}
}
return VINF_SUCCESS;
}
{
else
{
{
}
{
}
}
}
/*
* @return on success the number of bytes the command contained, otherwise - VERR_xxx error code
*/
static int vboxVDMACmdExecBlt(PVBOXVDMAHOST pVdma, const PVBOXVDMACMD_DMA_PRESENT_BLT pBlt, uint32_t cbBuffer)
{
const uint32_t cbBlt = VBOXVDMACMD_BODY_FIELD_OFFSET(uint32_t, VBOXVDMACMD_DMA_PRESENT_BLT, aDstSubRects[pBlt->cDstSubRects]);
return VERR_INVALID_FUNCTION;
/* we do not support stretching for now */
return VERR_INVALID_FUNCTION;
return VERR_INVALID_FUNCTION;
VBOXVDMA_RECTL updateRectl = {0};
if (pBlt->cDstSubRects)
{
{
{
}
{
}
if (!RT_SUCCESS(rc))
return rc;
}
}
else
{
if (!RT_SUCCESS(rc))
return rc;
}
int iView = 0;
/* @todo: fixme: check if update is needed and get iView */
return cbBlt;
}
{
do
{
if (!pvBuffer)
return VERR_INVALID_PARAMETER;
if (cbBuffer < VBOXVDMACMD_HEADER_SIZE())
return VERR_INVALID_PARAMETER;
{
{
#ifdef VBOXWDDM_TEST_UHGSMI
static int count = 0;
if (count==0)
{
start = RTTimeNanoTS();
}
++count;
if (count==100000)
{
end = RTTimeNanoTS();
}
#endif
/* todo: post the buffer to chromium */
return VINF_SUCCESS;
}
{
if (cbBlt >= 0)
{
return VINF_SUCCESS;
else
{
}
}
else
return cbBlt; /* error */
break;
}
default:
return VERR_INVALID_FUNCTION;
}
} while (1);
/* we should not be here */
return VERR_INVALID_STATE;
}
{
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
pPipe->bNeedNotify = true;
return VINF_SUCCESS;
// RTCritSectDelete(pPipe->hCritSect);
}
}
return rc;
}
{
if (RT_SUCCESS(rc))
{
{
pPipe->bNeedNotify = false;
rc = VINF_SUCCESS;
break;
pPipe->bNeedNotify = false;
break;
default:
break;
}
}
return rc;
}
{
if (RT_SUCCESS(rc))
{
{
rc = VINF_SUCCESS;
break;
break;
default:
break;
}
}
return rc;
}
{
if (RT_SUCCESS(rc))
{
bool bNeedNotify = false;
{
pPipe->bNeedNotify = false;
break;
pPipe->bNeedNotify = false;
break;
break;
default:
break;
}
if (bNeedNotify)
{
}
}
return rc;
}
typedef FNHVBOXVDMARWCB *PFNHVBOXVDMARWCB;
{
if (RT_SUCCESS(rc))
{
do
{
{
if (bProcessing)
{
rc = VINF_SUCCESS;
break;
}
{
break;
}
}
else
{
break;
}
if (!RT_SUCCESS(rc))
break;
if (!RT_SUCCESS(rc))
break;
} while (1);
}
return rc;
}
{
if (RT_SUCCESS(rc))
{
bool bNeedNotify = false;
{
if (bModified)
{
pPipe->bNeedNotify = false;
}
}
else
if (bNeedNotify)
{
}
}
return rc;
}
{
/* ensure the pipe is closed */
return VERR_INVALID_STATE;
return VINF_SUCCESS;
}
{
int rc;
bool bReleaseLocked = false;
do
{
{
}
else
{
{
/* @todo: more advanced mechanism of command buffer proc is actually needed */
break;
}
const void * pvPageBuf;
if (!RT_SUCCESS(rc))
{
/* @todo: if (rc == VERR_PGM_PHYS_PAGE_RESERVED) -> fall back on using PGMPhysRead ?? */
break;
}
bReleaseLocked = true;
}
if (bReleaseLocked)
} while (0);
}
{
}
typedef struct
{
struct VBOXVDMAHOST *pVdma;
bool bHasCmd;
{
if (pEntry)
{
return true;
}
return false;
}
{
if (RT_SUCCESS(rc))
{
do
{
if (RT_SUCCESS(rc))
{
{
{
break;
}
{
break;
}
default:
break;
}
{
rc = VINF_SUCCESS;
break;
}
}
else
break;
} while (1);
}
/* always try to close the pipe to make sure the client side is notified */
return rc;
}
{
int rc;
PVBOXVDMAHOST pVdma = (PVBOXVDMAHOST)RTMemAllocZ (RT_OFFSETOF(VBOXVDMAHOST, CmdPool.aCmds[cPipeElements]));
if (pVdma)
{
if (RT_SUCCESS(rc))
{
rc = RTThreadCreate(&pVdma->hWorkerThread, vboxVDMAWorkerThread, pVdma, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "VDMA");
if (RT_SUCCESS(rc))
{
for (uint32_t i = 0; i < cPipeElements; ++i)
{
}
#if 0 //def VBOX_WITH_CRHGSMI
# ifdef DEBUG_misha
# endif
#endif
return VINF_SUCCESS;
}
}
}
else
return rc;
}
{
return VINF_SUCCESS;
}
typedef struct
{
struct VBOXVDMAHOST *pVdma;
bool bQueued;
{
if (pEntry)
{
return true;
}
/* @todo: should we try to flush some commands here? */
return false;
}
{
#if 1
{
case VBOXVDMA_CTL_TYPE_ENABLE:
{
#ifdef VBOX_WITH_CRHGSMI
/* @todo: use async completion to ensure we notify a status to guest */
#endif
}
break;
break;
case VBOXVDMA_CTL_TYPE_FLUSH:
break;
default:
}
#else
/* test asinch completion */
if (RT_SUCCESS(rc))
{
{
/* success */
return;
}
}
/* failure */
#endif
}
{
#ifdef VBOX_WITH_CRHGSMI
return;
#endif
if (RT_SUCCESS(rc))
{
{
/* success */
return;
}
}
/* failure */
}
{
}