static int
VMwareXineramaIsActive(ClientPtr client)
{
xXineramaIsActiveReply rep;
ExtensionEntry *ext;
ScrnInfoPtr pScrn;
VMWAREPtr pVMWARE;
REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
if (!(ext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
return BadMatch;
}
pScrn = ext->extPrivate;
pVMWARE = VMWAREPTR(pScrn);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.state = pVMWARE->xinerama;
if(client->swapped) {
register int n;
_swaps(&rep.sequenceNumber, n);
_swapl(&rep.length, n);
_swapl(&rep.state, n);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep);
return client->noClientException;
}
static void
VMWARECopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
VMWAREPtr pVMWARE = VMWAREPTR(infoFromScreen(pWin->drawable.pScreen));
BoxPtr pBB;
Bool hidden = FALSE;
/*
* We only worry about the source region here, since shadowfb will
* take care of the destination region.
*/
pBB = REGION_EXTENTS(pWin->drawable.pScreen, prgnSrc);
VmwareLog(("VMWARECopyWindow(%p, (%d, %d), (%d, %d - %d, %d)\n",
pWin, ptOldOrg.x, ptOldOrg.y,
pBB->x1, pBB->y1, pBB->x2, pBB->y2));
if (BOX_INTERSECT(*pBB, pVMWARE->hwcur.box)) {
PRE_OP_HIDE_CURSOR();
hidden = TRUE;
}
pScreen->CopyWindow = pVMWARE->ScrnFuncs.CopyWindow;
(*pScreen->CopyWindow)(pWin, ptOldOrg, prgnSrc);
pScreen->CopyWindow = VMWARECopyWindow;
if (hidden) {
POST_OP_SHOW_CURSOR();
}
}
void
VMwareXinerama_ExtInit(ScrnInfoPtr pScrn)
{
ExtensionEntry *myext;
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Built-in Xinerama active, not initializing VMware Xinerama\n");
pVMWARE->xinerama = FALSE;
return;
}
#endif
if (!(myext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
if (!(myext = AddExtension(PANORAMIX_PROTOCOL_NAME, 0, 0,
VMwareXineramaDispatch,
SVMwareXineramaDispatch,
VMwareXineramaResetProc,
StandardMinorOpcode))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Failed to add VMware Xinerama extension.\n");
return;
}
pVMWARE->xinerama = TRUE;
myext->extPrivate = pScrn;
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Initialized VMware Xinerama extension.\n");
}
}
static void
vmwareLoadCursorARGB(ScrnInfoPtr pScrn, CursorPtr pCurs)
{
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
CARD32 width = pCurs->bits->width;
CARD32 height = pCurs->bits->height;
CARD32* image = pCurs->bits->argb;
CARD32* imageEnd = image + (width * height);
pVMWARE->cursorDefined = FALSE;
vmwareWriteWordToFIFO(pVMWARE, SVGA_CMD_DEFINE_ALPHA_CURSOR);
vmwareWriteWordToFIFO(pVMWARE, MOUSE_ID);
vmwareWriteWordToFIFO(pVMWARE, 0);
vmwareWriteWordToFIFO(pVMWARE, 0);
vmwareWriteWordToFIFO(pVMWARE, width);
vmwareWriteWordToFIFO(pVMWARE, height);
while (image != imageEnd) {
vmwareWriteWordToFIFO(pVMWARE, *image++);
}
vmwareWaitForFB(pVMWARE);
pVMWARE->cursorDefined = TRUE;
}
static void
VMWAREGetImage(DrawablePtr src, int x, int y, int w, int h,
unsigned int format, unsigned long planeMask, char *pBinImage)
{
ScreenPtr pScreen = src->pScreen;
VMWAREPtr pVMWARE = VMWAREPTR(infoFromScreen(src->pScreen));
BoxRec box;
Bool hidden = FALSE;
VmwareLog(("VMWAREGetImage(%p, %d, %d, %d, %d, %d, %d, %p)\n",
src, x, y, w, h, format, planeMask, pBinImage));
box.x1 = src->x + x;
box.y1 = src->y + y;
box.x2 = box.x1 + w;
box.y2 = box.y1 + h;
if (BOX_INTERSECT(box, pVMWARE->hwcur.box)) {
PRE_OP_HIDE_CURSOR();
hidden = TRUE;
}
pScreen->GetImage = pVMWARE->ScrnFuncs.GetImage;
(*pScreen->GetImage)(src, x, y, w, h, format, planeMask, pBinImage);
pScreen->GetImage = VMWAREGetImage;
if (hidden) {
POST_OP_SHOW_CURSOR();
}
}
void
vmwareCursorModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
if (pVMWARE->cursorDefined) {
vmwareWriteCursorRegs(pVMWARE, !pVMWARE->cursorShouldBeHidden, TRUE);
}
}
static Bool
vmwareUseHWCursor(ScreenPtr pScreen, CursorPtr pCurs)
{
ScrnInfoPtr pScrn = infoFromScreen(pScreen);
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
pVMWARE->hwcur.hotX = pCurs->bits->xhot;
pVMWARE->hwcur.hotY = pCurs->bits->yhot;
return pScrn->bitsPerPixel > 8;
}
static void
vmwareSetCursorColors(ScrnInfoPtr pScrn, int bg, int fg)
{
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
TRACEPOINT
if (pVMWARE->hwcur.fg != fg || pVMWARE->hwcur.bg != bg) {
VmwareLog(("SetCursorColors(0x%08x, 0x%08x)\n", bg, fg));
pVMWARE->hwcur.fg = fg;
pVMWARE->hwcur.bg = bg;
RedefineCursor(pVMWARE);
}
}
static void
vmwareLoadCursorImage(ScrnInfoPtr pScrn, unsigned char *src )
{
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
const int imageSize = SVGA_BITMAP_SIZE(pVMWARE->CursorInfoRec->MaxWidth,
pVMWARE->CursorInfoRec->MaxHeight);
TRACEPOINT
memcpy(pVMWARE->hwcur.source, src, imageSize * sizeof(uint32));
memcpy(pVMWARE->hwcur.mask,
src + imageSize * sizeof(uint32), imageSize * sizeof(uint32));
RedefineCursor(pVMWARE);
}
static void
vmwareHideCursor(ScrnInfoPtr pScrn)
{
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
#ifdef DEBUG_LOG_MOUSE_HIDE_SHOW
VmwareLog(("Hide: %d %d %d\n", pVMWARE->cursorSema, pVMWARE->cursorDefined,
pVMWARE->cursorShouldBeHidden));
#endif
if (pVMWARE->cursorDefined) {
vmwareWriteCursorRegs(pVMWARE, FALSE, TRUE);
}
pVMWARE->cursorShouldBeHidden = TRUE;
}
static int
VMwareXineramaQueryScreens(ClientPtr client)
{
xXineramaQueryScreensReply rep;
ExtensionEntry *ext;
ScrnInfoPtr pScrn;
VMWAREPtr pVMWARE;
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
if (!(ext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
return BadMatch;
}
pScrn = ext->extPrivate;
pVMWARE = VMWAREPTR(pScrn);
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.number = pVMWARE->xinerama ? pVMWARE->xineramaNumOutputs : 0;
rep.length = rep.number * sz_XineramaScreenInfo >> 2;
if(client->swapped) {
register int n;
_swaps(&rep.sequenceNumber, n);
_swapl(&rep.length, n);
_swapl(&rep.number, n);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *)&rep);
if(pVMWARE->xinerama) {
xXineramaScreenInfo scratch;
int i;
for(i = 0; i < pVMWARE->xineramaNumOutputs; i++) {
scratch.x_org = pVMWARE->xineramaState[i].x_org;
scratch.y_org = pVMWARE->xineramaState[i].y_org;
scratch.width = pVMWARE->xineramaState[i].width;
scratch.height = pVMWARE->xineramaState[i].height;
if(client->swapped) {
register int n;
_swaps(&scratch.x_org, n);
_swaps(&scratch.y_org, n);
_swaps(&scratch.width, n);
_swaps(&scratch.height, n);
}
WriteToClient(client, sz_XineramaScreenInfo, (char *)&scratch);
}
}
return client->noClientException;
}
static void
VMwareXineramaResetProc(ExtensionEntry* extEntry)
{
/* Called by CloseDownExtensions() */
ScrnInfoPtr pScrn = extEntry->extPrivate;
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
if (pVMWARE->xineramaState) {
free(pVMWARE->xineramaState);
pVMWARE->xineramaState = NULL;
pVMWARE->xineramaNumOutputs = 0;
pVMWARE->xinerama = FALSE;
}
}
Bool
vmwareCursorInit(ScreenPtr pScreen)
{
xf86CursorInfoPtr infoPtr;
VMWAREPtr pVMWARE = VMWAREPTR(infoFromScreen(pScreen));
Bool ret;
TRACEPOINT
/* Require cursor bypass for hwcursor. Ignore deprecated FIFO hwcursor */
if (!(pVMWARE->vmwareCapability & SVGA_CAP_CURSOR_BYPASS)) {
return FALSE;
}
infoPtr = xf86CreateCursorInfoRec();
if (!infoPtr)
return FALSE;
pVMWARE->CursorInfoRec = infoPtr;
infoPtr->MaxWidth = MAX_CURS;
infoPtr->MaxHeight = MAX_CURS;
infoPtr->Flags = HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |
HARDWARE_CURSOR_SOURCE_MASK_NOT_INTERLEAVED;
infoPtr->SetCursorColors = vmwareSetCursorColors;
infoPtr->SetCursorPosition = vmwareSetCursorPosition;
infoPtr->LoadCursorImage = vmwareLoadCursorImage;
infoPtr->HideCursor = vmwareHideCursor;
infoPtr->ShowCursor = vmwareShowCursor;
infoPtr->UseHWCursor = vmwareUseHWCursor;
#ifdef ARGB_CURSOR
if (pVMWARE->vmwareCapability & SVGA_CAP_ALPHA_CURSOR) {
infoPtr->UseHWCursorARGB = vmwareUseHWCursorARGB;
infoPtr->LoadCursorARGB = vmwareLoadCursorARGB;
}
#endif
ret = xf86InitCursor(pScreen, infoPtr);
if (!ret) {
xf86DestroyCursorInfoRec(infoPtr);
pVMWARE->CursorInfoRec = NULL;
}
return ret;
}
static int
VMwareXineramaGetScreenSize(ClientPtr client)
{
REQUEST(xPanoramiXGetScreenSizeReq);
WindowPtr pWin;
xPanoramiXGetScreenSizeReply rep;
register int n;
ExtensionEntry *ext;
ScrnInfoPtr pScrn;
VMWAREPtr pVMWARE;
int rc;
REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (!(ext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
return BadMatch;
}
pScrn = ext->extPrivate;
pVMWARE = VMWAREPTR(pScrn);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.width = pVMWARE->xineramaState[stuff->screen].width;
rep.height = pVMWARE->xineramaState[stuff->screen].height;
rep.window = stuff->window;
rep.screen = stuff->screen;
if(client->swapped) {
_swaps(&rep.sequenceNumber, n);
_swapl(&rep.length, n);
_swapl(&rep.width, n);
_swapl(&rep.height, n);
_swapl(&rep.window, n);
_swapl(&rep.screen, n);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *)&rep);
return client->noClientException;
}
void
vmwareCursorCloseScreen(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = infoFromScreen(pScreen);
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
pScreen->GetImage = pVMWARE->ScrnFuncs.GetImage;
pScreen->CopyWindow = pVMWARE->ScrnFuncs.CopyWindow;
#ifdef RENDER
if (ps) {
ps->Composite = pVMWARE->Composite;
}
#endif /* RENDER */
vmwareHideCursor(pScrn);
xf86DestroyCursorInfoRec(pVMWARE->CursorInfoRec);
}
static void
VMWAREComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask,
PicturePtr pDst, INT16 xSrc, INT16 ySrc,
INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst,
CARD16 width, CARD16 height)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
VMWAREPtr pVMWARE = VMWAREPTR(infoFromScreen(pScreen));
PictureScreenPtr ps = GetPictureScreen(pScreen);
BoxRec box;
Bool hidden = FALSE;
VmwareLog(("VMWAREComposite op = %d, pSrc = %p, pMask = %p, pDst = %p,"
" src = (%d, %d), mask = (%d, %d), dst = (%d, %d), w = %d,"
" h = %d\n", op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask,
xDst, yDst, width, height));
/*
* We only worry about the source region here, since shadowfb or XAA will
* take care of the destination region.
*/
box.x1 = pSrc->pDrawable->x + xSrc;
box.y1 = pSrc->pDrawable->y + ySrc;
box.x2 = box.x1 + width;
box.y2 = box.y1 + height;
if (BOX_INTERSECT(box, pVMWARE->hwcur.box)) {
PRE_OP_HIDE_CURSOR();
hidden = TRUE;
}
ps->Composite = pVMWARE->Composite;
(*ps->Composite)(op, pSrc, pMask, pDst, xSrc, ySrc,
xMask, yMask, xDst, yDst, width, height);
ps->Composite = VMWAREComposite;
if (hidden) {
POST_OP_SHOW_CURSOR();
}
}
static void
vmwareSetCursorPosition(ScrnInfoPtr pScrn, int x, int y)
{
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
#ifdef DEBUG_LOG_MOUSE_MOVE
VmwareLog(("Move: %d %d %d\n", pVMWARE->cursorSema, pVMWARE->cursorDefined,
pVMWARE->cursorShouldBeHidden));
#endif
/*
* We're bad people. We have no concept of a frame (VMWAREAdjustFrame()
* is a NOP). The hwcursor code expects us to be frame aware though, so
* we have to do this. I'm open to suggestions. I tried not even
* hooking AdjustFrame and it didn't help.
*/
pVMWARE->hwcur.x = x + pScrn->frameX0;
pVMWARE->hwcur.y = y + pScrn->frameY0;
pVMWARE->hwcur.box.x1 = pVMWARE->hwcur.x;
pVMWARE->hwcur.box.x2 = pVMWARE->hwcur.x + pVMWARE->CursorInfoRec->MaxWidth;
pVMWARE->hwcur.box.y1 = pVMWARE->hwcur.y;
pVMWARE->hwcur.box.y2 = pVMWARE->hwcur.y + pVMWARE->CursorInfoRec->MaxHeight;
vmwareShowCursor(pScrn);
}
void
vmwareCursorHookWrappers(ScreenPtr pScreen)
{
VMWAREPtr pVMWARE = VMWAREPTR(infoFromScreen(pScreen));
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
TRACEPOINT
pVMWARE->ScrnFuncs.GetImage = pScreen->GetImage;
pVMWARE->ScrnFuncs.CopyWindow = pScreen->CopyWindow;
pScreen->GetImage = VMWAREGetImage;
pScreen->CopyWindow = VMWARECopyWindow;
#ifdef RENDER
if (ps) {
pVMWARE->Composite = ps->Composite;
ps->Composite = VMWAREComposite;
}
#endif /* RENDER */
}
void
vmwareAddDefaultMode(ScrnInfoPtr pScrn, uint32 dwidth, uint32 dheight)
{
DisplayModePtr *monitorModes = &pScrn->monitor->Modes;
DisplayModePtr modes = NULL;
if (monitorModes == NULL || *monitorModes == NULL) {
goto out_err;
}
#ifdef HAVE_XORG_SERVER_1_2_0
if (dwidth && dheight) {
MonPtr monitor = pScrn->monitor;
DisplayModePtr mode = NULL;
DisplayModeRec dynamic =
{ MODEPREFIX, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, MODESUFFIX };
unsigned dispModeCount = 0;
char **dispModeList;
char *dynModeName;
char name[80];
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
/* First, add the default mode name to the display mode
* requests.
*/
snprintf(name, sizeof(name), VMW_DEFLT_MODE_NAME, dwidth, dheight);
dynModeName = xnfstrdup(name);
if (!dynModeName || !pScrn->display)
goto out_err;
if (pScrn->display->modes) {
dispModeList = pScrn->display->modes;
while(*dispModeList)
dispModeList++;
dispModeCount = (unsigned)(((size_t)dispModeList -
(size_t)pScrn->display->modes) /
sizeof(*dispModeList));
}
dispModeList = xnfcalloc(dispModeCount + 2, sizeof(*dispModeList));
if (!dispModeList)
goto out_err;
memcpy(dispModeList, pScrn->display->modes,
dispModeCount * sizeof(*dispModeList));
dispModeList[dispModeCount] = dynModeName;
pScrn->display->modes = dispModeList;
/* Then, add the default mode itself.
*/
dynamic.name = name;
dynamic.HDisplay = dwidth;
dynamic.HSyncStart = dynamic.HDisplay + 1;
dynamic.HSyncEnd = dynamic.HSyncStart + 1;
dynamic.HTotal = dynamic.HSyncEnd * 5 / 4;
dynamic.VDisplay = dheight;
dynamic.VSyncStart = dynamic.VDisplay + 1;
dynamic.VSyncEnd = dynamic.VSyncStart + 1;
dynamic.VTotal = dynamic.VSyncEnd + 1;
if (monitor->nVrefresh > 0)
dynamic.VRefresh = monitor->vrefresh[0].lo;
else
dynamic.VRefresh = 60;
dynamic.Clock = dynamic.VRefresh * dynamic.VTotal *
dynamic.HTotal / 1000;
mode = xf86DuplicateMode(&dynamic);
modes = xf86ModesAdd(modes, mode);
if (dispModeCount == 0) {
/*
* Set up a large virtual size, so that we allow also
* setting modes larger than the initial mode.
*
* We might also want to consider the case where
* dispModeCount != 0, but the requested display modes
* are not available. This is sufficient for now.
*/
if (pScrn->display->virtualX == 0)
pScrn->display->virtualX = pVMWARE->maxWidth;
if (pScrn->display->virtualY == 0)
pScrn->display->virtualY = pVMWARE->maxHeight;
}
}
*monitorModes = xf86ModesAdd(*monitorModes, modes);
#else
(void) modes;
#endif
return;
out_err:
xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Failed to add default mode.");
}
