git.sesse.net Git - rdpsrv/blob - Xserver/programs/Xserver/Xext/xf86dga.c

   1 /* $XFree86: xc/programs/Xserver/Xext/xf86dga.c,v 3.8 1997/01/18 06:53:01 dawes Exp $ */
   2
   3 /*
   4
   5 Copyright (c) 1995  Jon Tombs
   6 Copyright (c) 1995, 1996  XFree86 Inc
   7
   8 */
   9
  10 #define NEED_REPLIES
  11 #define NEED_EVENTS
  12 #include "X.h"
  13 #include "Xproto.h"
  14 #include "misc.h"
  15 #include "dixstruct.h"
  16 #include "extnsionst.h"
  17 #include "colormapst.h"
  18 #include "cursorstr.h"
  19 #include "scrnintstr.h"
  20 #include "servermd.h"
  21 #define _XF86DGA_SERVER_
  22 #include "xf86dgastr.h"
  23 #include "swaprep.h"
  24 #include "../hw/xfree86/common/xf86.h"
  25
  26 #include <X11/Xtrans.h>
  27 #include "../os/osdep.h"
  28 #include <X11/Xauth.h>
  29 #ifndef ESIX
  30 #ifndef Lynx
  31 #include <sys/socket.h>
  32 #else
  33 #include <socket.h>
  34 #endif
  35 #else
  36 #include <lan/socket.h>
  37 #endif
  38
  39 extern int xf86ScreenIndex;
  40
  41 static int DGAErrorBase;
  42
  43 static DISPATCH_PROC(ProcDGAQueryVersion);
  44 static DISPATCH_PROC(ProcXF86DGADirectVideo);
  45 static DISPATCH_PROC(ProcXF86DGADispatch);
  46 static DISPATCH_PROC(ProcXF86DGAGetVidPage);
  47 static DISPATCH_PROC(ProcXF86DGAGetVideoLL);
  48 static DISPATCH_PROC(ProcXF86DGAGetViewPortSize);
  49 static DISPATCH_PROC(ProcXF86DGASetVidPage);
  50 static DISPATCH_PROC(ProcXF86DGASetViewPort);
  51 static DISPATCH_PROC(ProcDGAInstallColormap);
  52 static DISPATCH_PROC(ProcDGAQueryDirectVideo);
  53 static DISPATCH_PROC(ProcDGAViewPortChanged);
  54
  55 /*
  56  * SProcs should probably be deleted, a local connection can never
  57  * be byte flipped!? - Jon.
  58  */
  59 static DISPATCH_PROC(SProcXF86DGADirectVideo);
  60 static DISPATCH_PROC(SProcXF86DGADispatch);
  61 static DISPATCH_PROC(SProcXF86DGAQueryVersion);
  62
  63 static void XF86DGAResetProc(
  64 #if NeedFunctionPrototypes
  65     ExtensionEntry* /* extEntry */
  66 #endif
  67 );
  68
  69 static unsigned char DGAReqCode = 0;
  70
  71 void
  72 XFree86DGAExtensionInit()
  73 {
  74     ExtensionEntry* extEntry;
  75 #ifdef XF86DGA_EVENTS
  76     int             i;
  77     ScreenPtr       pScreen;
  78
  79     EventType = CreateNewResourceType(XF86DGAFreeEvents);
  80     ScreenPrivateIndex = AllocateScreenPrivateIndex ();
  81     for (i = 0; i < screenInfo.numScreens; i++)
  82     {
  83         pScreen = screenInfo.screens[i];
  84         SetScreenPrivate (pScreen, NULL);
  85     }
  86 #endif
  87
  88     if (
  89 #ifdef XF86DGA_EVENTS
  90         EventType && ScreenPrivateIndex != -1 &&
  91 #endif
  92         (extEntry = AddExtension(XF86DGANAME,
  93                                 XF86DGANumberEvents,
  94                                 XF86DGANumberErrors,
  95                                 ProcXF86DGADispatch,
  96                                 SProcXF86DGADispatch,
  97                                 XF86DGAResetProc,
  98                                 StandardMinorOpcode))) {
  99         DGAReqCode = (unsigned char)extEntry->base;
 100         DGAErrorBase = extEntry->errorBase;
 101     }
 102 }
 103
 104 /*ARGSUSED*/
 105 static void
 106 XF86DGAResetProc (extEntry)
 107     ExtensionEntry* extEntry;
 108 {
 109 }
 110
 111 static int
 112 ProcDGAQueryVersion(client)
 113     register ClientPtr client;
 114 {
 115     xXF86DGAQueryVersionReply rep;
 116     register int n;
 117
 118     REQUEST_SIZE_MATCH(xXF86DGAQueryVersionReq);
 119     rep.type = X_Reply;
 120     rep.length = 0;
 121     rep.sequenceNumber = client->sequence;
 122     rep.majorVersion = XF86DGA_MAJOR_VERSION;
 123     rep.minorVersion = XF86DGA_MINOR_VERSION;
 124     if (client->swapped) {
 125         swaps(&rep.sequenceNumber, n);
 126         swapl(&rep.length, n);
 127     }
 128     WriteToClient(client, sizeof(xXF86DGAQueryVersionReply), (char *)&rep);
 129     return (client->noClientException);
 130 }
 131
 132 static int
 133 ProcXF86DGAGetVideoLL(client)
 134     register ClientPtr client;
 135 {
 136     REQUEST(xXF86DGAGetVideoLLReq);
 137     xXF86DGAGetVideoLLReply rep;
 138     ScrnInfoPtr vptr;
 139     register int n;
 140
 141     if (stuff->screen > screenInfo.numScreens)
 142         return BadValue;
 143
 144     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 145     REQUEST_SIZE_MATCH(xXF86DGAGetVideoLLReq);
 146     rep.type = X_Reply;
 147     rep.length = 0;
 148     rep.sequenceNumber = client->sequence;
 149 #if 0
 150     xf86GetVidMemData(stuff->screen, &rep.offset, &rep.bank_size);
 151 #else
 152     rep.offset = vptr->physBase;
 153     rep.bank_size = vptr->physSize;
 154 #endif
 155     rep.width = vptr->displayWidth;
 156     rep.ram_size = vptr->videoRam;
 157
 158     if (client->swapped) {
 159         swaps(&rep.sequenceNumber, n);
 160         swapl(&rep.length, n);
 161         swapl(&rep.offset, n);
 162         swapl(&rep.width, n);
 163         swapl(&rep.bank_size, n);
 164         swapl(&rep.ram_size, n);
 165     }
 166     WriteToClient(client, SIZEOF(xXF86DGAGetVideoLLReply), (char *)&rep);
 167     return (client->noClientException);
 168 }
 169
 170 static int
 171 ProcXF86DGADirectVideo(client)
 172     register ClientPtr client;
 173 {
 174     REQUEST(xXF86DGADirectVideoReq);
 175     ScrnInfoPtr vptr;
 176
 177     if (stuff->screen > screenInfo.numScreens)
 178         return BadValue;
 179
 180     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 181
 182     REQUEST_SIZE_MATCH(xXF86DGADirectVideoReq);
 183     if (!(vptr->directMode&XF86DGADirectPresent)) {
 184        /* chipset doesn't know about directVideoMode */
 185         return DGAErrorBase + XF86DGANoDirectVideoMode;
 186     }
 187
 188     /* Check that the current screen is active. */
 189     if (!xf86VTSema && !(vptr->directMode & XF86DGADirectGraphics)) {
 190         return DGAErrorBase + XF86DGAScreenNotActive;
 191     }
 192
 193     if (stuff->enable&XF86DGADirectGraphics) {
 194        vptr->directMode = stuff->enable|XF86DGADirectPresent;
 195        if (xf86VTSema == TRUE) {
 196           vptr->EnterLeaveVT(LEAVE, stuff->screen);
 197           xf86VTSema = FALSE;
 198        }
 199     } else {
 200        if (xf86VTSema == FALSE) {
 201           xf86VTSema = TRUE;
 202           vptr->EnterLeaveVT(ENTER, stuff->screen);
 203        }
 204        vptr->directMode = (0x0f&stuff->enable)|XF86DGADirectPresent;
 205     }
 206
 207     return (client->noClientException);
 208 }
 209
 210 static int
 211 ProcXF86DGAGetViewPortSize(client)
 212     register ClientPtr client;
 213 {
 214     REQUEST(xXF86DGAGetViewPortSizeReq);
 215     xXF86DGAGetViewPortSizeReply rep;
 216     register int n;
 217     ScrnInfoPtr vptr;
 218
 219     if (stuff->screen > screenInfo.numScreens)
 220         return BadValue;
 221
 222     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 223
 224     REQUEST_SIZE_MATCH(xXF86DGAGetViewPortSizeReq);
 225     rep.type = X_Reply;
 226     rep.length = 0;
 227     rep.sequenceNumber = client->sequence;
 228     rep.width = vptr->modes->HDisplay;
 229     rep.height = vptr->modes->VDisplay;
 230
 231     if (client->swapped) {
 232         swaps(&rep.sequenceNumber, n);
 233         swapl(&rep.length, n);
 234         swapl(&rep.width, n);
 235         swapl(&rep.height, n);
 236     }
 237     WriteToClient(client, SIZEOF(xXF86DGAGetViewPortSizeReply), (char *)&rep);
 238     return (client->noClientException);
 239 }
 240
 241 static int
 242 ProcXF86DGASetViewPort(client)
 243     register ClientPtr client;
 244 {
 245     REQUEST(xXF86DGASetViewPortReq);
 246     ScrnInfoPtr vptr;
 247
 248     if (stuff->screen > screenInfo.numScreens)
 249         return BadValue;
 250
 251     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 252
 253     REQUEST_SIZE_MATCH(xXF86DGASetViewPortReq);
 254
 255     if (vptr->AdjustFrame &&
 256         (xf86VTSema == TRUE || vptr->directMode&XF86DGADirectGraphics))
 257         vptr->AdjustFrame(stuff->x, stuff->y);
 258     else
 259         return DGAErrorBase + XF86DGAScreenNotActive;
 260
 261     return (client->noClientException);
 262 }
 263
 264 static int
 265 ProcXF86DGAGetVidPage(client)
 266     register ClientPtr client;
 267 {
 268     REQUEST(xXF86DGAGetVidPageReq);
 269     ScrnInfoPtr vptr;
 270
 271     if (stuff->screen > screenInfo.numScreens)
 272         return BadValue;
 273
 274     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 275     ErrorF("XF86DGAGetVidPage not yet implemented\n");
 276
 277     REQUEST_SIZE_MATCH(xXF86DGAGetVidPageReq);
 278     return (client->noClientException);
 279 }
 280
 281
 282 static int
 283 ProcXF86DGASetVidPage(client)
 284     register ClientPtr client;
 285 {
 286     REQUEST(xXF86DGASetVidPageReq);
 287     ScrnInfoPtr vptr;
 288
 289     if (stuff->screen > screenInfo.numScreens)
 290         return BadValue;
 291
 292     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 293
 294     REQUEST_SIZE_MATCH(xXF86DGASetVidPageReq);
 295
 296     if (xf86VTSema == TRUE) {/* only valid when switched away! */
 297         return DGAErrorBase + XF86DGADirectNotActivated;
 298     }
 299     if (!xf86VTSema && !(vptr->directMode & XF86DGADirectGraphics)) {
 300         return DGAErrorBase + XF86DGAScreenNotActive;
 301     }
 302
 303     if (vptr->setBank) {
 304         vptr->setBank(stuff->vpage);
 305     }
 306     return (client->noClientException);
 307 }
 308
 309
 310 static int
 311 ProcDGAInstallColormap(client)
 312     register ClientPtr client;
 313 {
 314     ColormapPtr pcmp;
 315     ScrnInfoPtr vptr;
 316     REQUEST(xXF86DGAInstallColormapReq);
 317
 318     REQUEST_SIZE_MATCH(xXF86DGAInstallColormapReq);
 319
 320     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 321
 322     if (xf86VTSema == TRUE) {/* only valid when switched away! */
 323         return DGAErrorBase + XF86DGADirectNotActivated;
 324     }
 325     if (!xf86VTSema && !(vptr->directMode & XF86DGADirectGraphics)) {
 326         return DGAErrorBase + XF86DGAScreenNotActive;
 327     }
 328
 329     pcmp = (ColormapPtr  )LookupIDByType(stuff->id, RT_COLORMAP);
 330     if (pcmp)
 331     {
 332         vptr->directMode |= XF86DGADirectColormap;
 333         vptr->directMode |= XF86DGAHasColormap;
 334         (*(pcmp->pScreen->InstallColormap)) (pcmp);
 335         vptr->directMode &= ~XF86DGAHasColormap;
 336         return (client->noClientException);
 337     }
 338     else
 339     {
 340         client->errorValue = stuff->id;
 341         return (BadColor);
 342     }
 343 }
 344
 345 static int
 346 ProcXF86DGAQueryDirectVideo(client)
 347     register ClientPtr client;
 348 {
 349     REQUEST(xXF86DGAQueryDirectVideoReq);
 350     xXF86DGAQueryDirectVideoReply rep;
 351     register int n;
 352     ScrnInfoPtr vptr;
 353
 354     if (stuff->screen > screenInfo.numScreens)
 355         return BadValue;
 356
 357     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 358
 359     REQUEST_SIZE_MATCH(xXF86DGAQueryDirectVideoReq);
 360     rep.type = X_Reply;
 361     rep.length = 0;
 362     rep.sequenceNumber = client->sequence;
 363     rep.flags = vptr->directMode;
 364
 365     if (client->swapped) {
 366         swaps(&rep.sequenceNumber, n);
 367         swapl(&rep.length, n);
 368         swapl(&rep.flags, n);
 369     }
 370     WriteToClient(client, SIZEOF(xXF86DGAQueryDirectVideoReply), (char *)&rep);
 371     return (client->noClientException);
 372 }
 373
 374 static int
 375 ProcXF86DGAViewPortChanged(client)
 376     register ClientPtr client;
 377 {
 378     REQUEST(xXF86DGAViewPortChangedReq);
 379     xXF86DGAViewPortChangedReply rep;
 380     register int n;
 381     ScrnInfoPtr vptr;
 382
 383     if (stuff->screen > screenInfo.numScreens)
 384         return BadValue;
 385
 386     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 387
 388     REQUEST_SIZE_MATCH(xXF86DGAViewPortChangedReq);
 389     rep.type = X_Reply;
 390     rep.length = 0;
 391     rep.sequenceNumber = client->sequence;
 392     /* For the moment, always return TRUE. */
 393     rep.result = TRUE;
 394
 395     if (client->swapped) {
 396         swaps(&rep.sequenceNumber, n);
 397         swapl(&rep.length, n);
 398         swapl(&rep.result, n);
 399     }
 400     WriteToClient(client, SIZEOF(xXF86DGAViewPortChangedReply), (char *)&rep);
 401     return (client->noClientException);
 402 }
 403
 404 static int
 405 ProcXF86DGADispatch (client)
 406     register ClientPtr  client;
 407 {
 408     REQUEST(xReq);
 409
 410     if (!LocalClient(client))
 411         return DGAErrorBase + XF86DGAClientNotLocal;
 412
 413     switch (stuff->data)
 414     {
 415     case X_XF86DGAQueryVersion:
 416         return ProcDGAQueryVersion(client);
 417     case X_XF86DGAGetVideoLL:
 418         return ProcXF86DGAGetVideoLL(client);
 419     case X_XF86DGADirectVideo:
 420         return ProcXF86DGADirectVideo(client);
 421     case X_XF86DGAGetViewPortSize:
 422         return ProcXF86DGAGetViewPortSize(client);
 423     case X_XF86DGASetViewPort:
 424         return ProcXF86DGASetViewPort(client);
 425     case X_XF86DGAGetVidPage:
 426         return ProcXF86DGAGetVidPage(client);
 427     case X_XF86DGASetVidPage:
 428         return ProcXF86DGASetVidPage(client);
 429     case X_XF86DGAInstallColormap:
 430         return ProcDGAInstallColormap(client);
 431     case X_XF86DGAQueryDirectVideo:
 432         return ProcXF86DGAQueryDirectVideo(client);
 433     case X_XF86DGAViewPortChanged:
 434         return ProcXF86DGAViewPortChanged(client);
 435     default:
 436         return BadRequest;
 437     }
 438 }
 439
 440 static int
 441 SProcXF86DGAQueryVersion(client)
 442     register ClientPtr  client;
 443 {
 444     register int n;
 445     REQUEST(xXF86DGAQueryVersionReq);
 446     swaps(&stuff->length, n);
 447     return ProcDGAQueryVersion(client);
 448 }
 449
 450 static int
 451 SProcXF86DGADirectVideo(client)
 452     ClientPtr client;
 453 {
 454     register int n;
 455     REQUEST(xXF86DGADirectVideoReq);
 456     swaps(&stuff->length, n);
 457     REQUEST_SIZE_MATCH(xXF86DGADirectVideoReq);
 458     swaps(&stuff->screen, n);
 459     swaps(&stuff->enable, n);
 460     return ProcXF86DGADirectVideo(client);
 461 }
 462
 463 static int
 464 SProcXF86DGADispatch (client)
 465     register ClientPtr  client;
 466 {
 467     REQUEST(xReq);
 468
 469     /* It is bound to be non-local when there is byte swapping */
 470     if (!LocalClient(client))
 471         return DGAErrorBase + XF86DGAClientNotLocal;
 472
 473     switch (stuff->data)
 474     {
 475     case X_XF86DGAQueryVersion:
 476         return SProcXF86DGAQueryVersion(client);
 477     case X_XF86DGADirectVideo:
 478         return SProcXF86DGADirectVideo(client);
 479     default:
 480         return BadRequest;
 481     }
 482 }
 483