XFree86-voodoo-Rush.patch

   1 diff -c -N -r xc.old/config/cf/X11.tmpl xc/config/cf/X11.tmpl
   2 *** xc.old/config/cf/X11.tmpl   Mon Mar  2 03:55:22 1998
   3 --- xc/config/cf/X11.tmpl       Sat Apr 11 13:56:54 1998
   4 ***************
   5 *** 202,207 ****
   6 --- 202,213 ----
   7   #ifndef BuildXF86DGALibrary
   8   #define BuildXF86DGALibrary   BuildXF86DGA
   9   #endif
  10 + #ifndef BuildXF86RushExt
  11 + #define BuildXF86RushExt      NO
  12 + #endif
  13 + #ifndef BuildXF86RushLibrary
  14 + #define BuildXF86RushLibrary  BuildXF86RushExt
  15 + #endif
  16   #ifndef BuildDPMSExt
  17   #define BuildDPMSExt          NO
  18   #endif
  19 ***************
  20 *** 992,997 ****
  21 --- 998,1019 ----
  22   #endif
  23   #endif
  24
  25 + #if BuildXF86RushLibrary
  26 + #ifndef SharedLibXxf86rush
  27 + #define SharedLibXxf86rush    YES
  28 + #endif
  29 + #ifndef NormalLibXxf86rush
  30 + #define NormalLibXxf86rush    YES
  31 + #endif
  32 + #ifndef DebugLibXxf86rush
  33 + #define DebugLibXxf86rush     NO
  34 + #endif
  35 + #ifndef ProfileLibXxf86rush
  36 + #define ProfileLibXxf86rush   NO
  37 + #endif
  38 + #endif
  39 +
  40 +
  41   #if BuildDPMSLibrary
  42   #ifndef SharedLibXdpms
  43   #define SharedLibXdpms                NO
  44 ***************
  45 *** 1078,1083 ****
  46 --- 1100,1117 ----
  47   SharedLibReferences(XXF86DGA,Xxf86dga,$(XXF86DGALIBSRC),SOXXF86DGAREV,SharedXxf86dgaRev)
  48   #else
  49   ProjectUnsharedLibReferences(XXF86DGA,Xxf86dga,$(XXF86DGALIBSRC),XBuildLibDir)
  50 + #endif
  51 + #endif
  52 +
  53 + #if BuildXF86RushLibrary
  54 +    XXF86RUSHLIBSRC = $(LIBSRC)/Xxf86rush
  55 + #if SharedLibXxf86rush
  56 + #ifndef SharedXxf86RushRev
  57 + #define SharedXxf86RushRev 1.0
  58 + #endif
  59 + SharedLibReferences(XXF86RUSH,Xxf86rush,$(XXF86RUSHLIBSRC),SOXXF86RUSHREV,SharedXxf86RushRev)
  60 + #else
  61 + ProjectUnsharedLibReferences(XXF86RUSH,Xxf86rush,$(XXF86RUSHLIBSRC),XBuildLibDir)
  62   #endif
  63   #endif
  64
  65 diff -c -N -r xc.old/config/cf/xfree86.cf xc/config/cf/xfree86.cf
  66 *** xc.old/config/cf/xfree86.cf Mon Mar  2 03:55:22 1998
  67 --- xc/config/cf/xfree86.cf     Sat Apr 11 15:34:02 1998
  68 ***************
  69 *** 619,624 ****
  70 --- 619,627 ----
  71   #ifndef BuildDPMSLibrary
  72   #define BuildDPMSLibrary      YES
  73   #endif
  74 + #ifndef BuildXF86RushLibrary
  75 + #define BuildXF86RushLibrary  YES
  76 + #endif
  77
  78   /*
  79    * Build the XFree86-VidMode extension
  80 ***************
  81 *** 673,678 ****
  82 --- 676,688 ----
  83   #define BuildDPMSExt                  YES
  84   #endif
  85
  86 + /*
  87 +  * Build the Rush extension support
  88 +  */
  89 + #ifndef BuildXF86RushExt
  90 + #define BuildXF86RushExt              YES
  91 + #endif
  92 +
  93   #if Malloc0ReturnsNull
  94   #ifndef XtMalloc0ReturnsNullDefines
  95   #define XtMalloc0ReturnsNullDefines   Malloc0ReturnsNullDefines -DXTMALLOC_BC
  96 ***************
  97 *** 764,769 ****
  98 --- 774,785 ----
  99   #define XFree86DGADefines     /**/
 100   #endif
 101
 102 + #if BuildXF86RushExt
 103 + #define XFree86RushDefines    -DXFreeXRUSH
 104 + #else
 105 + #define XFree86RushDefines    /**/
 106 + #endif
 107 +
 108   #ifndef MakeHasPosixVariableSubstitutions
 109   #if !HasBsdMake
 110   #define MakeHasPosixVariableSubstitutions     NO
 111 ***************
 112 *** 774,780 ****
 113
 114   /* Server defines required for all OSs */
 115   #ifndef XFree86ServerDefines
 116 ! #define XFree86ServerDefines  -DSTATIC_COLOR -DAVOID_GLYPHBLT -DPIXPRIV LinkKitDefines XFree86DGADefines
 117   #endif
 118
 119   #ifndef XFree86ServerOSDefines
 120 --- 790,796 ----
 121
 122   /* Server defines required for all OSs */
 123   #ifndef XFree86ServerDefines
 124 ! #define XFree86ServerDefines  -DSTATIC_COLOR -DAVOID_GLYPHBLT -DPIXPRIV LinkKitDefines XFree86DGADefines XFree86RushDefines
 125   #endif
 126
 127   #ifndef XFree86ServerOSDefines
 128 *** xc.old/include/extensions/Imakefile Sun Jan 12 02:39:14 1997
 129 --- xc/include/extensions/Imakefile     Sun Apr  5 17:34:16 1998
 130 ***************
 131 *** 14,19 ****
 132 --- 14,22 ----
 133   #if BuildXF86DGALibrary
 134   XF86DGAHEADERS = xf86dga.h xf86dgastr.h
 135   #endif
 136 + #if BuildXF86RushLibrary
 137 + XF86RUSHHEADERS = xf86rush.h xf86rushstr.h
 138 + #endif
 139   #if BuildLBX
 140   LBXHEADERS = lbxbuf.h lbxbufstr.h lbxdeltastr.h lbximage.h lbxopts.h lbxstr.h lbxzlib.h
 141   #endif
 142 ***************
 143 *** 21,27 ****
 144   DPMSHEADERS = dpms.h dpmsstr.h
 145   #endif
 146
 147 ! EXTRAHEADERS = $(SCREENSAVERHEADERS) $(XF86VIDMODEHEADERS) $(XF86DGAHEADERS) $(XF86MISCHEADERS) $(LBXHEADERS) $(DPMSHEADERS)
 148
 149
 150
 151 --- 24,30 ----
 152   DPMSHEADERS = dpms.h dpmsstr.h
 153   #endif
 154
 155 ! EXTRAHEADERS = $(SCREENSAVERHEADERS) $(XF86VIDMODEHEADERS) $(XF86DGAHEADERS) $(XF86RUSHHEADERS) $(XF86MISCHEADERS) $(LBXHEADERS) $(DPMSHEADERS)
 156
 157
 158
 159 diff -c -N -r xc.old/include/extensions/xf86rush.h xc/include/extensions/xf86rush.h
 160 *** xc.old/include/extensions/xf86rush.h        Wed Dec 31 16:00:00 1969
 161 --- xc/include/extensions/xf86rush.h    Sun Apr 19 15:56:23 1998
 162 ***************
 163 *** 0 ****
 164 --- 1,70 ----
 165 + /* $$ */
 166 + /*
 167 +
 168 + Copyright (c) 1998  Daryll Strauss
 169 +
 170 + */
 171 +
 172 + #ifndef _XF86RUSH_H_
 173 + #define _XF86RUSH_H_
 174 +
 175 + #include <X11/Xfuncproto.h>
 176 +
 177 + #define X_XF86RushQueryVersion                0
 178 + #define X_XF86RushLockPixmap          1
 179 + #define X_XF86RushUnlockPixmap                2
 180 + #define X_XF86RushUnlockAllPixmaps    3
 181 +
 182 + #define XF86RushNumberEvents          0
 183 +
 184 + #define XF86RushClientNotLocal                0
 185 + #define XF86RushNumberErrors          (XF86RushClientNotLocal + 1)
 186 +
 187 + #ifndef _XF86RUSH_SERVER_
 188 +
 189 + _XFUNCPROTOBEGIN
 190 +
 191 + Bool XF86RushQueryVersion(
 192 + #if NeedFunctionPrototypes
 193 +     Display*          /* dpy */,
 194 +     int*              /* majorVersion */,
 195 +     int*              /* minorVersion */
 196 + #endif
 197 + );
 198 +
 199 + Bool XF86RushQueryExtension(
 200 + #if NeedFunctionPrototypes
 201 +     Display*          /* dpy */,
 202 +     int*              /* event_base */,
 203 +     int*              /* error_base */
 204 + #endif
 205 + );
 206 +
 207 + Bool XF86RushLockPixmap(
 208 + #if NeedFunctionPrototypes
 209 +     Display *         /* dpy */,
 210 +     int                       /* screen */,
 211 +     Pixmap            /* Pixmap */,
 212 +     void **           /* Return address */
 213 + #endif
 214 + );
 215 +
 216 + Bool XF86RushUnlockPixmap(
 217 + #if NeedFunctionPrototypes
 218 +     Display *         /* dpy */,
 219 +     int                       /* screen */,
 220 +     Pixmap            /* Pixmap */
 221 + #endif
 222 + );
 223 +
 224 + Bool XF86RushUnlockAllPixmaps(
 225 + #if NeedFunctionPrototypes
 226 +     Display *         /* dpy */
 227 + #endif
 228 + );
 229 +
 230 + _XFUNCPROTOEND
 231 +
 232 + #endif /* _XF86RUSH_SERVER_ */
 233 +
 234 + #endif /* _XF86RUSH_H_ */
 235 diff -c -N -r xc.old/include/extensions/xf86rushstr.h xc/include/extensions/xf86rushstr.h
 236 *** xc.old/include/extensions/xf86rushstr.h     Wed Dec 31 16:00:00 1969
 237 --- xc/include/extensions/xf86rushstr.h Sun Apr  5 21:44:32 1998
 238 ***************
 239 *** 0 ****
 240 --- 1,82 ----
 241 + /* $$ */
 242 + /*
 243 +
 244 + Copyright (c) 1998  Daryll Strauss
 245 +
 246 + */
 247 +
 248 + #ifndef _XF86RUSHSTR_H_
 249 + #define _XF86RUSHSTR_H_
 250 +
 251 + #include "xf86rush.h"
 252 +
 253 + #define XF86RUSHNAME "XFree86-Rush"
 254 +
 255 + #define XF86RUSH_MAJOR_VERSION        1       /* current version numbers */
 256 + #define XF86RUSH_MINOR_VERSION        0
 257 +
 258 + typedef struct _XF86RushQueryVersion {
 259 +     CARD8     reqType;                /* always RushReqCode */
 260 +     CARD8     rushReqType;            /* always X_RushQueryVersion */
 261 +     CARD16    length B16;
 262 + } xXF86RushQueryVersionReq;
 263 + #define sz_xXF86RushQueryVersionReq   4
 264 +
 265 + typedef struct {
 266 +     BYTE      type;                   /* X_Reply */
 267 +     BOOL      pad1;
 268 +     CARD16    sequenceNumber B16;
 269 +     CARD32    length B32;
 270 +     CARD16    majorVersion B16;       /* major version of Rush protocol */
 271 +     CARD16    minorVersion B16;       /* minor version of Rush protocol */
 272 +     CARD32    pad2 B32;
 273 +     CARD32    pad3 B32;
 274 +     CARD32    pad4 B32;
 275 +     CARD32    pad5 B32;
 276 +     CARD32    pad6 B32;
 277 + } xXF86RushQueryVersionReply;
 278 + #define sz_xXF86RushQueryVersionReply 32
 279 +
 280 + typedef struct _XF86RushLockPixmap {
 281 +     CARD8     reqType;                /* always RushReqCode */
 282 +     CARD8     rushReqType;            /* always X_RushLockPixmap */
 283 +     CARD16    length B16;
 284 +     CARD16    screen B16;
 285 +     CARD16    pad B16;
 286 +     CARD32    pixmap B32;
 287 + } xXF86RushLockPixmapReq;
 288 + #define sz_xXF86RushLockPixmapReq     12
 289 +
 290 + typedef struct {
 291 +     BYTE      type;
 292 +     BOOL      pad1;
 293 +     CARD16    sequenceNumber B16;
 294 +     CARD32    length B32;
 295 +     CARD32    addr B32;
 296 +     CARD32    pad2 B32;
 297 +     CARD32    pad3 B32;
 298 +     CARD32    pad4 B32;
 299 +     CARD32    pad5 B32;
 300 +     CARD32    pad6 B32;
 301 + } xXF86RushLockPixmapReply;
 302 + #define sz_xXF86RushLockPixmapReply   32
 303 +
 304 + typedef struct _XF86RushUnlockPixmap {
 305 +     CARD8     reqType;                /* always RushReqCode */
 306 +     CARD8     rushReqType;            /* always X_RushUnlockPixmap */
 307 +     CARD16    length B16;
 308 +     CARD16    screen B16;
 309 +     CARD16    pad B16;
 310 +     CARD32    pixmap B32;
 311 + } xXF86RushUnlockPixmapReq;
 312 + #define sz_xXF86RushUnlockPixmapReq   12
 313 +
 314 + typedef struct _XF86RushUnlockAllPixmaps {
 315 +     CARD8     reqType;                /* always RushReqCode */
 316 +     CARD8     rushReqType;            /* always X_RushUnlockAllPixmaps */
 317 +     CARD16      length B16;
 318 + } xXF86RushUnlockAllPixmapsReq;
 319 + #define sz_xXF86RushUnlockAllPixmapsReq   4
 320 +
 321 + #endif /* _XF86RUSHSTR_H_ */
 322 +
 323 diff -c -N -r xc.old/lib/Imakefile xc/lib/Imakefile
 324 *** xc.old/lib/Imakefile        Sat Jul  5 08:55:33 1997
 325 --- xc/lib/Imakefile    Sat Apr 11 13:24:59 1998
 326 ***************
 327 *** 39,45 ****
 328   XF86DGALIB = Xxf86dga
 329   #endif
 330
 331 ! XF86EXTLIBS = $(XF86MISCLIB) $(XF86VMLIB) $(XF86DGALIB)
 332
 333   #if BuildDPMSLibrary
 334   XDPMSLIBDIR = Xdpms
 335 --- 39,49 ----
 336   XF86DGALIB = Xxf86dga
 337   #endif
 338
 339 ! #if BuildXF86RushLibrary
 340 ! XF86RUSHLIB = Xxf86rush
 341 ! #endif
 342 !
 343 ! XF86EXTLIBS = $(XF86MISCLIB) $(XF86VMLIB) $(XF86DGALIB) $(XF86RUSHLIB)
 344
 345   #if BuildDPMSLibrary
 346   XDPMSLIBDIR = Xdpms
 347 ***************
 348 *** 61,67 ****
 349
 350   #if !BuildServersOnly
 351   LINTSUBDIRS = Xau Xdmcp $(THRSTUBLIB) X11 oldX ICE SM Xext Xt \
 352 !            $(SSLIB) $(XF86MISCLIB) $(XF86VMLIB) $(XF86DGALIB) \
 353              Xmu Xaw XIE Xi Xtst FS \
 354              PEX5 $(XKBLIBDIR) $(XKBUILIBDIR) $(LBXUTILDIR) $(XALIBDIR) \
 355              $(XDPMSLIBDIR) \
 356 --- 65,71 ----
 357
 358   #if !BuildServersOnly
 359   LINTSUBDIRS = Xau Xdmcp $(THRSTUBLIB) X11 oldX ICE SM Xext Xt \
 360 !            $(SSLIB) $(XF86MISCLIB) $(XF86VMLIB) $(XF86DGALIB) $(XF86RUSHLIB) \
 361              Xmu Xaw XIE Xi Xtst FS \
 362              PEX5 $(XKBLIBDIR) $(XKBUILIBDIR) $(LBXUTILDIR) $(XALIBDIR) \
 363              $(XDPMSLIBDIR) \
 364 diff -c -N -r xc.old/lib/Xext/XF86Rush.c xc/lib/Xext/XF86Rush.c
 365 *** xc.old/lib/Xext/XF86Rush.c  Wed Dec 31 16:00:00 1969
 366 --- xc/lib/Xext/XF86Rush.c      Sun Apr  5 18:01:55 1998
 367 ***************
 368 *** 0 ****
 369 --- 1,163 ----
 370 + /* $$ */
 371 + /*
 372 +
 373 + Copyright (c) 1998 Daryll Strauss
 374 +
 375 + */
 376 +
 377 + /* THIS IS NOT AN X CONSORTIUM STANDARD */
 378 +
 379 + #define NEED_EVENTS
 380 + #define NEED_REPLIES
 381 + #include "Xlibint.h"
 382 + #include "xf86rushstr.h"
 383 + #include "Xext.h"
 384 + #include "extutil.h"
 385 +
 386 + static XExtensionInfo _xf86rush_info_data;
 387 + static XExtensionInfo *xf86rush_info = &_xf86rush_info_data;
 388 + static char *xf86rush_extension_name = XF86RUSHNAME;
 389 +
 390 + #define XF86RushCheckExtension(dpy,i,val) \
 391 +   XextCheckExtension (dpy, i, xf86rush_extension_name, val)
 392 +
 393 + /*****************************************************************************
 394 +  *                                                                           *
 395 +  *                       private utility routines                          *
 396 +  *                                                                           *
 397 +  *****************************************************************************/
 398 +
 399 + static int close_display();
 400 + static /* const */ XExtensionHooks xf86rush_extension_hooks = {
 401 +     NULL,                             /* create_gc */
 402 +     NULL,                             /* copy_gc */
 403 +     NULL,                             /* flush_gc */
 404 +     NULL,                             /* free_gc */
 405 +     NULL,                             /* create_font */
 406 +     NULL,                             /* free_font */
 407 +     close_display,                    /* close_display */
 408 +     NULL,                             /* wire_to_event */
 409 +     NULL,                             /* event_to_wire */
 410 +     NULL,                             /* error */
 411 +     NULL,                             /* error_string */
 412 + };
 413 +
 414 + static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86rush_info,
 415 +                                  xf86rush_extension_name,
 416 +                                  &xf86rush_extension_hooks,
 417 +                                  0, NULL)
 418 +
 419 + static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86rush_info)
 420 +
 421 +
 422 + /*****************************************************************************
 423 +  *                                                                           *
 424 +  *                public XFree86-DGA Extension routines                *
 425 +  *                                                                           *
 426 +  *****************************************************************************/
 427 +
 428 + Bool XF86RushQueryExtension (dpy, event_basep, error_basep)
 429 +     Display *dpy;
 430 +     int *event_basep, *error_basep;
 431 + {
 432 +     XExtDisplayInfo *info = find_display (dpy);
 433 +
 434 +     if (XextHasExtension(info)) {
 435 +       *event_basep = info->codes->first_event;
 436 +       *error_basep = info->codes->first_error;
 437 +       return True;
 438 +     } else {
 439 +       return False;
 440 +     }
 441 + }
 442 +
 443 + Bool XF86RushQueryVersion(dpy, majorVersion, minorVersion)
 444 +     Display* dpy;
 445 +     int* majorVersion;
 446 +     int* minorVersion;
 447 + {
 448 +     XExtDisplayInfo *info = find_display (dpy);
 449 +     xXF86RushQueryVersionReply rep;
 450 +     xXF86RushQueryVersionReq *req;
 451 +
 452 +     XF86RushCheckExtension (dpy, info, False);
 453 +
 454 +     LockDisplay(dpy);
 455 +     GetReq(XF86RushQueryVersion, req);
 456 +     req->reqType = info->codes->major_opcode;
 457 +     req->dgaReqType = X_XF86RushQueryVersion;
 458 +     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 459 +       UnlockDisplay(dpy);
 460 +       SyncHandle();
 461 +       return False;
 462 +     }
 463 +     *majorVersion = rep.majorVersion;
 464 +     *minorVersion = rep.minorVersion;
 465 +     UnlockDisplay(dpy);
 466 +     SyncHandle();
 467 +     return True;
 468 + }
 469 +
 470 + Bool XF86RushLockPixmap(dpy, screen, pixmap, addr)
 471 +      Display *dpy;
 472 +      int screen;
 473 +      Pixmap pixmap;
 474 +      void **addr;
 475 + {
 476 +   XExtDisplayInfo *info = find_display (dpy);
 477 +   xXF86RushLockPixmapReply rep;
 478 +   xXF86RushLockPixmapReq *req;
 479 +
 480 +   XF86RushCheckExtension (dpy, info, False);
 481 +   LockDisplay(dpy);
 482 +   GetReq(XF86RushLockPixmap, req);
 483 +   req->reqType = info->codes->major_opcode;
 484 +   req->dgaReqType = X_XF86RushLockPixmap;
 485 +   req->screen=screen;
 486 +   req->pixmap=pixmap;
 487 +   if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 488 +     UnlockDisplay(dpy);
 489 +     SyncHandle();
 490 +     return False;
 491 +   }
 492 +   *addr=(void*)rep.addr;
 493 +   UnlockDisplay(dpy);
 494 +   SyncHandle();
 495 +   return True;
 496 + }
 497 +
 498 + Bool XF86RushUnlockPixmap(dpy, screen, pixmap)
 499 +      Display *dpy;
 500 +      int screen;
 501 +      Pixmap pixmap;
 502 + {
 503 +   XExtDisplayInfo *info = find_display(dpy);
 504 +   xXF86RushUnlockPixmapReq *req;
 505 +
 506 +   XF86RushCheckExtension (dpy, info, False);
 507 +   LockDisplay(dpy);
 508 +   GetReq(XF86RushUnlockPixmap, req);
 509 +   req->reqType = info->codes->major_opcode;
 510 +   req->dgaReqType = X_XF86RushUnlockPixmap;
 511 +   req->screen=screen;
 512 +   req->pixmap=pixmap;
 513 +   UnlockDisplay(dpy);
 514 +   SyncHandle();
 515 +   return True;
 516 + }
 517 +
 518 + Bool XF86RushUnlockAllPixmaps(dpy)
 519 +      Display *dpy;
 520 + {
 521 +   XExtDisplayInfo *info = find_display(dpy);
 522 +   xXF86RushUnlockAllPixmapsReq *req;
 523 +
 524 +   XF86RushCheckExtension (dpy, info, False);
 525 +   LockDisplay(dpy);
 526 +   GetReq(XF86RushUnlockAllPixmaps, req);
 527 +   req->reqType = info->codes->major_opcode;
 528 +   req->dgaReqType = X_XF86RushUnlockAllPixmaps;
 529 +   UnlockDisplay(dpy);
 530 +   SyncHandle();
 531 +   return True;
 532 + }
 533 diff -c -N -r xc.old/lib/Xxf86rush/Imakefile xc/lib/Xxf86rush/Imakefile
 534 *** xc.old/lib/Xxf86rush/Imakefile      Wed Dec 31 16:00:00 1969
 535 --- xc/lib/Xxf86rush/Imakefile  Sat Apr 11 13:29:38 1998
 536 ***************
 537 *** 0 ****
 538 --- 1,33 ----
 539 + XCOMM $$
 540 + #define DoNormalLib NormalLibXxf86rush
 541 + #define DoSharedLib SharedLibXxf86rush
 542 + #define DoDebugLib DebugLibXxf86rush
 543 + #define DoProfileLib ProfileLibXxf86rush
 544 + #define LibName Xxf86rush
 545 + #define SoRev SOXXF86RUSHREV
 546 + #define LibHeaders NO
 547 +
 548 + #include <Threads.tmpl>
 549 +
 550 + #ifdef SharedXxf86rushReqs
 551 + REQUIREDLIBS = SharedXxf86rushReqs
 552 + #endif
 553 +
 554 + XF86RUSHSRCS = XF86Rush.c
 555 + XF86RUSHOBJS = XF86Rush.o
 556 +
 557 + #if Malloc0ReturnsNull
 558 + ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
 559 + #endif
 560 +
 561 +       DEFINES = $(ALLOC_DEFINES)
 562 +      INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC)
 563 +          SRCS = $(XF86RUSHSRCS)
 564 +          OBJS = $(XF86RUSHOBJS)
 565 +      LINTLIBS = $(LINTXLIB)
 566 +
 567 + #include <Library.tmpl>
 568 +
 569 + DependTarget()
 570 +
 571 +
 572 diff -c -N -r xc.old/lib/Xxf86rush/XF86Rush.c xc/lib/Xxf86rush/XF86Rush.c
 573 *** xc.old/lib/Xxf86rush/XF86Rush.c     Wed Dec 31 16:00:00 1969
 574 --- xc/lib/Xxf86rush/XF86Rush.c Sat Apr 11 13:55:40 1998
 575 ***************
 576 *** 0 ****
 577 --- 1,163 ----
 578 + /* $$ */
 579 + /*
 580 +
 581 + Copyright (c) 1998 Daryll Strauss
 582 +
 583 + */
 584 +
 585 + /* THIS IS NOT AN X CONSORTIUM STANDARD */
 586 +
 587 + #define NEED_EVENTS
 588 + #define NEED_REPLIES
 589 + #include "Xlibint.h"
 590 + #include "xf86rushstr.h"
 591 + #include "Xext.h"
 592 + #include "extutil.h"
 593 +
 594 + static XExtensionInfo _xf86rush_info_data;
 595 + static XExtensionInfo *xf86rush_info = &_xf86rush_info_data;
 596 + static char *xf86rush_extension_name = XF86RUSHNAME;
 597 +
 598 + #define XF86RushCheckExtension(dpy,i,val) \
 599 +   XextCheckExtension (dpy, i, xf86rush_extension_name, val)
 600 +
 601 + /*****************************************************************************
 602 +  *                                                                           *
 603 +  *                       private utility routines                          *
 604 +  *                                                                           *
 605 +  *****************************************************************************/
 606 +
 607 + static int close_display();
 608 + static /* const */ XExtensionHooks xf86rush_extension_hooks = {
 609 +     NULL,                             /* create_gc */
 610 +     NULL,                             /* copy_gc */
 611 +     NULL,                             /* flush_gc */
 612 +     NULL,                             /* free_gc */
 613 +     NULL,                             /* create_font */
 614 +     NULL,                             /* free_font */
 615 +     close_display,                    /* close_display */
 616 +     NULL,                             /* wire_to_event */
 617 +     NULL,                             /* event_to_wire */
 618 +     NULL,                             /* error */
 619 +     NULL,                             /* error_string */
 620 + };
 621 +
 622 + static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86rush_info,
 623 +                                  xf86rush_extension_name,
 624 +                                  &xf86rush_extension_hooks,
 625 +                                  0, NULL)
 626 +
 627 + static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86rush_info)
 628 +
 629 +
 630 + /*****************************************************************************
 631 +  *                                                                           *
 632 +  *                public XFree86-DGA Extension routines                *
 633 +  *                                                                           *
 634 +  *****************************************************************************/
 635 +
 636 + Bool XF86RushQueryExtension (dpy, event_basep, error_basep)
 637 +     Display *dpy;
 638 +     int *event_basep, *error_basep;
 639 + {
 640 +     XExtDisplayInfo *info = find_display (dpy);
 641 +
 642 +     if (XextHasExtension(info)) {
 643 +       *event_basep = info->codes->first_event;
 644 +       *error_basep = info->codes->first_error;
 645 +       return True;
 646 +     } else {
 647 +       return False;
 648 +     }
 649 + }
 650 +
 651 + Bool XF86RushQueryVersion(dpy, majorVersion, minorVersion)
 652 +     Display* dpy;
 653 +     int* majorVersion;
 654 +     int* minorVersion;
 655 + {
 656 +     XExtDisplayInfo *info = find_display (dpy);
 657 +     xXF86RushQueryVersionReply rep;
 658 +     xXF86RushQueryVersionReq *req;
 659 +
 660 +     XF86RushCheckExtension (dpy, info, False);
 661 +
 662 +     LockDisplay(dpy);
 663 +     GetReq(XF86RushQueryVersion, req);
 664 +     req->reqType = info->codes->major_opcode;
 665 +     req->rushReqType = X_XF86RushQueryVersion;
 666 +     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 667 +       UnlockDisplay(dpy);
 668 +       SyncHandle();
 669 +       return False;
 670 +     }
 671 +     *majorVersion = rep.majorVersion;
 672 +     *minorVersion = rep.minorVersion;
 673 +     UnlockDisplay(dpy);
 674 +     SyncHandle();
 675 +     return True;
 676 + }
 677 +
 678 + Bool XF86RushLockPixmap(dpy, screen, pixmap, addr)
 679 +      Display *dpy;
 680 +      int screen;
 681 +      Pixmap pixmap;
 682 +      void **addr;
 683 + {
 684 +   XExtDisplayInfo *info = find_display (dpy);
 685 +   xXF86RushLockPixmapReply rep;
 686 +   xXF86RushLockPixmapReq *req;
 687 +
 688 +   XF86RushCheckExtension (dpy, info, False);
 689 +   LockDisplay(dpy);
 690 +   GetReq(XF86RushLockPixmap, req);
 691 +   req->reqType = info->codes->major_opcode;
 692 +   req->rushReqType = X_XF86RushLockPixmap;
 693 +   req->screen=screen;
 694 +   req->pixmap=pixmap;
 695 +   if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 696 +     UnlockDisplay(dpy);
 697 +     SyncHandle();
 698 +     return False;
 699 +   }
 700 +   *addr=(void*)rep.addr;
 701 +   UnlockDisplay(dpy);
 702 +   SyncHandle();
 703 +   return True;
 704 + }
 705 +
 706 + Bool XF86RushUnlockPixmap(dpy, screen, pixmap)
 707 +      Display *dpy;
 708 +      int screen;
 709 +      Pixmap pixmap;
 710 + {
 711 +   XExtDisplayInfo *info = find_display(dpy);
 712 +   xXF86RushUnlockPixmapReq *req;
 713 +
 714 +   XF86RushCheckExtension (dpy, info, False);
 715 +   LockDisplay(dpy);
 716 +   GetReq(XF86RushUnlockPixmap, req);
 717 +   req->reqType = info->codes->major_opcode;
 718 +   req->rushReqType = X_XF86RushUnlockPixmap;
 719 +   req->screen=screen;
 720 +   req->pixmap=pixmap;
 721 +   UnlockDisplay(dpy);
 722 +   SyncHandle();
 723 +   return True;
 724 + }
 725 +
 726 + Bool XF86RushUnlockAllPixmaps(dpy)
 727 +      Display *dpy;
 728 + {
 729 +   XExtDisplayInfo *info = find_display(dpy);
 730 +   xXF86RushUnlockAllPixmapsReq *req;
 731 +
 732 +   XF86RushCheckExtension (dpy, info, False);
 733 +   LockDisplay(dpy);
 734 +   GetReq(XF86RushUnlockAllPixmaps, req);
 735 +   req->reqType = info->codes->major_opcode;
 736 +   req->rushReqType = X_XF86RushUnlockAllPixmaps;
 737 +   UnlockDisplay(dpy);
 738 +   SyncHandle();
 739 +   return True;
 740 + }
 741 diff -c -N -r xc.old/programs/Xserver/Xext/Imakefile ./Xext/Imakefile
 742 *** xc.old/programs/Xserver/Xext/Imakefile      Fri Jan 23 04:35:11 1998
 743 --- xc/programs/Xserver/Xext/Imakefile  Sun Apr  4 18:13:41 1999
 744 ***************
 745 *** 32,37 ****
 746 --- 32,42 ----
 747    DPMSOBJS = dpms.o
 748   #endif
 749
 750 + #if BuildXF86RushExt
 751 +  XF86RRUSHSRCS = xf86Rush.c
 752 +  XF86RUSHOBJS = xf86Rush.o
 753 + #endif
 754 +
 755   #if BuildAppgroup
 756     APPGROUPSRCS = appgroup.c
 757     APPGROUPOBJS = appgroup.o
 758 ***************
 759 *** 47,59 ****
 760                 mitmisc.c xtest.c xtest1di.c xtest1dd.c sleepuntil.c \
 761               bigreq.c sync.c $(SCRNSAVSRC) xcmisc.c $(VIDMODESRCS) \
 762               $(XF86MISCSRCS) $(XF86DGASRCS) $(SECURITYSRCS) \
 763 !             $(DPMSSRCS) \
 764               $(APPGROUPSRCS) xprint.c
 765          OBJS = shape.o $(SHMOBJS) mbuf.o \
 766                 mitmisc.o xtest.o xtest1di.o xtest1dd.o sleepuntil.o \
 767                 bigreq.o sync.o $(SCRNSAVOBJ) xcmisc.o $(VIDMODEOBJS) \
 768               $(XF86MISCOBJS) $(XF86DGAOBJS) $(SECURITYOBJS) \
 769 !             $(DPMSOBJS) \
 770               $(APPGROUPOBJS) xprint.o
 771
 772   XF86INCLUDES = -I../hw/xfree86/common -I../hw/xfree86/os-support
 773 --- 52,64 ----
 774                 mitmisc.c xtest.c xtest1di.c xtest1dd.c sleepuntil.c \
 775               bigreq.c sync.c $(SCRNSAVSRC) xcmisc.c $(VIDMODESRCS) \
 776               $(XF86MISCSRCS) $(XF86DGASRCS) $(SECURITYSRCS) \
 777 !             $(DPMSSRCS) $(XF86RUSHSRCS) \
 778               $(APPGROUPSRCS) xprint.c
 779          OBJS = shape.o $(SHMOBJS) mbuf.o \
 780                 mitmisc.o xtest.o xtest1di.o xtest1dd.o sleepuntil.o \
 781                 bigreq.o sync.o $(SCRNSAVOBJ) xcmisc.o $(VIDMODEOBJS) \
 782               $(XF86MISCOBJS) $(XF86DGAOBJS) $(SECURITYOBJS) \
 783 !             $(DPMSOBJS) $(XF86RUSHOBJS) \
 784               $(APPGROUPOBJS) xprint.o
 785
 786   XF86INCLUDES = -I../hw/xfree86/common -I../hw/xfree86/os-support
 787 diff -c -N -r xc.old/programs/Xserver/Xext/xf86Rush.c ./Xext/xf86Rush.c
 788 *** xc.old/programs/Xserver/Xext/xf86Rush.c     Wed Dec 31 16:00:00 1969
 789 --- xc/programs/Xserver/Xext/xf86Rush.c Sun Apr  4 18:13:41 1999
 790 ***************
 791 *** 0 ****
 792 --- 1,213 ----
 793 + /* $XFree86: $ */
 794 +
 795 + /*
 796 +
 797 + Copyright (c) 1998 Daryll Strauss
 798 +
 799 + */
 800 +
 801 + #define NEED_REPLIES
 802 + #define NEED_EVENTS
 803 + #include "X.h"
 804 + #include "Xproto.h"
 805 + #include "misc.h"
 806 + #include "dixstruct.h"
 807 + #include "extnsionst.h"
 808 + #include "colormapst.h"
 809 + #include "cursorstr.h"
 810 + #include "scrnintstr.h"
 811 + #include "servermd.h"
 812 + #define _XF86RUSH_SERVER_
 813 + #include "xf86rushstr.h"
 814 + #include "swaprep.h"
 815 + #include "../hw/xfree86/common/xf86.h"
 816 + #include <dlfcn.h>
 817 +
 818 + #include <X11/Xtrans.h>
 819 + #include "../os/osdep.h"
 820 + #include <X11/Xauth.h>
 821 + #ifndef ESIX
 822 + #ifndef Lynx
 823 + #include <sys/socket.h>
 824 + #else
 825 + #include <socket.h>
 826 + #endif
 827 + #else
 828 + #include <lan/socket.h>
 829 + #endif
 830 +
 831 + extern int xf86ScreenIndex;
 832 + static unsigned char RushReqCode = 0;
 833 + static int RushErrorBase;
 834 +
 835 + static DISPATCH_PROC(ProcXF86RushDispatch);
 836 + static DISPATCH_PROC(ProcRushQueryVersion);
 837 + static DISPATCH_PROC(ProcRushLockPixmap);
 838 + static DISPATCH_PROC(ProcRushUnlockPixmap);
 839 + static DISPATCH_PROC(ProcRushUnlockAllPixmaps);
 840 +
 841 + static DISPATCH_PROC(SProcXF86RushDispatch);
 842 +
 843 + static void XF86RushResetProc(
 844 + #if NeedFunctionPrototypes
 845 +     ExtensionEntry* /* extEntry */
 846 + #endif
 847 + );
 848 +
 849 + void
 850 + XFree86RushExtensionInit()
 851 + {
 852 +     ExtensionEntry* extEntry;
 853 +
 854 +     if (
 855 +       (extEntry = AddExtension(XF86RUSHNAME,
 856 +                               XF86RushNumberEvents,
 857 +                               XF86RushNumberErrors,
 858 +                               ProcXF86RushDispatch,
 859 +                               SProcXF86RushDispatch,
 860 +                               XF86RushResetProc,
 861 +                               StandardMinorOpcode))) {
 862 +       RushReqCode = (unsigned char)extEntry->base;
 863 +       RushErrorBase = extEntry->errorBase;
 864 +     }
 865 + }
 866 +
 867 + /*ARGSUSED*/
 868 + static void
 869 + XF86RushResetProc (extEntry)
 870 +     ExtensionEntry* extEntry;
 871 + {
 872 + }
 873 +
 874 + static int
 875 + ProcRushQueryVersion(client)
 876 +     register ClientPtr client;
 877 + {
 878 +     xXF86RushQueryVersionReply rep;
 879 +     register int n;
 880 +
 881 +     REQUEST_SIZE_MATCH(xXF86RushQueryVersionReq);
 882 +     rep.type = X_Reply;
 883 +     rep.length = 0;
 884 +     rep.sequenceNumber = client->sequence;
 885 +     rep.majorVersion = XF86RUSH_MAJOR_VERSION;
 886 +     rep.minorVersion = XF86RUSH_MINOR_VERSION;
 887 +     if (client->swapped) {
 888 +       swaps(&rep.sequenceNumber, n);
 889 +       swapl(&rep.length, n);
 890 +     }
 891 +     WriteToClient(client, sizeof(xXF86RushQueryVersionReply), (char *)&rep);
 892 +     return (client->noClientException);
 893 + }
 894 +
 895 + static int
 896 + ProcXF86RushLockPixmap(client)
 897 +      register ClientPtr client;
 898 + {
 899 +   REQUEST(xXF86RushLockPixmapReq);
 900 +   xXF86RushLockPixmapReply rep;
 901 +   ScrnInfoPtr vptr;
 902 +   PixmapPtr pix;
 903 +   void *handle;
 904 +   void *(*func)();
 905 +
 906 +   if (stuff->screen > screenInfo.numScreens)
 907 +     return BadValue;
 908 +
 909 +   vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 910 +
 911 +   REQUEST_SIZE_MATCH(xXF86RushLockPixmapReq);
 912 +   rep.type = X_Reply;
 913 +   rep.length = 0;
 914 +   rep.sequenceNumber = client->sequence;
 915 +   pix = (PixmapPtr)SecurityLookupIDByType(client,
 916 +                                         stuff->pixmap, RT_PIXMAP,
 917 +                                         SecurityReadAccess);
 918 +   handle=dlopen(0, 0);
 919 +   if (handle) {
 920 +     func=(void*(*)())dlsym(handle, "xf86LockPixmap");
 921 +     dlclose(handle);
 922 +   }
 923 +   if (handle && func) rep.addr=(int)func(pix);
 924 +   else rep.addr = 0;
 925 +
 926 +   WriteToClient(client, SIZEOF(xXF86RushLockPixmapReply), (char*)&rep);
 927 +   return client->noClientException;
 928 + }
 929 +
 930 + static int
 931 + ProcXF86RushUnlockPixmap(client)
 932 +      register ClientPtr client;
 933 + {
 934 +   REQUEST(xXF86RushUnlockPixmapReq);
 935 +   ScrnInfoPtr vptr;
 936 +   PixmapPtr pix;
 937 +   void *handle;
 938 +   void (*func)();
 939 +
 940 +   if (stuff->screen > screenInfo.numScreens)
 941 +     return BadValue;
 942 +
 943 +   vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 944 +   REQUEST_SIZE_MATCH(xXF86RushUnlockPixmapReq);
 945 +   pix = (PixmapPtr)SecurityLookupIDByType(client,
 946 +                                         stuff->pixmap, RT_PIXMAP,
 947 +                                         SecurityReadAccess);
 948 +   handle=dlopen(0, 0);
 949 +   if (handle) {
 950 +     func=(void(*)())dlsym(handle, "xf86UnlockPixmap");
 951 +     dlclose(handle);
 952 +   }
 953 +   if (handle && func) func(pix);
 954 +   return client->noClientException;
 955 + }
 956 +
 957 + static int
 958 + ProcXF86RushUnlockAllPixmaps(client)
 959 +      register ClientPtr client;
 960 + {
 961 +   void *handle;
 962 +   void (*func)();
 963 +
 964 +   REQUEST(xXF86RushUnlockAllPixmapsReq);
 965 +   REQUEST_SIZE_MATCH(xXF86RushUnlockAllPixmapsReq);
 966 +   handle=dlopen(0, 0);
 967 +   if (handle) {
 968 +     func=(void(*)())dlsym(handle, "xf86UnlockAllPixmaps");
 969 +     dlclose(handle);
 970 +   }
 971 +   if (handle && func) func();
 972 +   return client->noClientException;
 973 + }
 974 +
 975 + ProcXF86RushDispatch (client)
 976 +     register ClientPtr        client;
 977 + {
 978 +     REQUEST(xReq);
 979 +
 980 +     if (!LocalClient(client))
 981 +       return RushErrorBase + XF86RushClientNotLocal;
 982 +
 983 +     switch (stuff->data)
 984 +     {
 985 +     case X_XF86RushQueryVersion:
 986 +       return ProcRushQueryVersion(client);
 987 +     case X_XF86RushLockPixmap:
 988 +         return ProcXF86RushLockPixmap(client);
 989 +     case X_XF86RushUnlockPixmap:
 990 +         return ProcXF86RushUnlockPixmap(client);
 991 +     case X_XF86RushUnlockAllPixmaps:
 992 +         return ProcXF86RushUnlockAllPixmaps(client);
 993 +     default:
 994 +       return BadRequest;
 995 +     }
 996 + }
 997 +
 998 + SProcXF86RushDispatch (client)
 999 +     register ClientPtr        client;
1000 + {
1001 +     REQUEST(xReq);
1002 +
1003 +     return RushErrorBase + XF86RushClientNotLocal;
1004 + }
1005 +
1006 diff -c -N -r xc.old/programs/Xserver/hw/xfree86/LinkKit/Imakefile ./hw/xfree86/LinkKit/Imakefile
1007 *** xc.old/programs/Xserver/hw/xfree86/LinkKit/Imakefile        Sun Jan 12 02:41:28 1997
1008 --- xc/programs/Xserver/hw/xfree86/LinkKit/Imakefile    Sun Apr  4 18:13:41 1999
1009 ***************
1010 *** 73,78 ****
1011 --- 73,79 ----
1012         LimitBoolean("BuildXF86VidModeExt", NO, BuildXF86VidModeExt) >> $@
1013         LimitBoolean("BuildXF86MiscExt", NO, BuildXF86MiscExt) >> $@
1014         LimitBoolean("BuildXF86DGA", NO, BuildXF86DGA) >> $@
1015 +       LimitBoolean("BuildXF86RushExt", NO, BuildXF86RushExt) >> $@
1016         LimitBoolean("BuildDPMSExt", BuildDPMSExt, BuildDPMSExt) >> $@
1017
1018   clean::
1019 diff -c -N -r xc.old/programs/Xserver/hw/xfree86/common/xf86Cursor.c ./hw/xfree86/common/xf86Cursor.c
1020 *** xc.old/programs/Xserver/hw/xfree86/common/xf86Cursor.c      Sat Oct 31 12:13:18 1998
1021 --- xc/programs/Xserver/hw/xfree86/common/xf86Cursor.c  Sun Apr  4 18:13:41 1999
1022 ***************
1023 *** 138,143 ****
1024 --- 138,150 ----
1025     Bool          frameChanged = FALSE;
1026     ScrnInfoPtr   pScr = XF86SCRNINFO(pScreen);
1027
1028 + #ifdef XFreeXDGA
1029 +   /*
1030 +    * Since we're in DGA mode we need to trash this scroll request
1031 +    */
1032 +    if (pScr->directMode&XF86DGADirectGraphics)
1033 +    return;
1034 + #endif
1035     /*
1036      * check wether (x,y) belongs to the visual part of the screen
1037      * if not, change the base of the displayed frame accoring
1038 diff -c -N -r xc.old/programs/Xserver/hw/xfree86/vga256/drivers/apm/apm_cursor.c ./hw/xfree86/vga256/drivers/apm/apm_cursor.c
1039 *** xc.old/programs/Xserver/hw/xfree86/vga256/drivers/apm/apm_cursor.c  Sun Jan 18 02:35:30 1998
1040 --- xc/programs/Xserver/hw/xfree86/vga256/drivers/apm/apm_cursor.c      Sun Apr  4 18:13:42 1999
1041 ***************
1042 *** 23,29 ****
1043   #include "apm.h"
1044
1045   static void  ApmShowCursor(void);
1046 ! static void  ApmHideCursor(void);
1047   static Bool  ApmRealizeCursor(ScreenPtr pScr, CursorPtr pCurs);
1048   static Bool  ApmUnrealizeCursor(ScreenPtr pScr, CursorPtr pCurs);
1049   static void  ApmLoadCursorToCard(ScreenPtr pScr, CursorPtr pCurs, int x, int y);
1050 --- 23,29 ----
1051   #include "apm.h"
1052
1053   static void  ApmShowCursor(void);
1054 ! void  ApmHideCursor(void);
1055   static Bool  ApmRealizeCursor(ScreenPtr pScr, CursorPtr pCurs);
1056   static Bool  ApmUnrealizeCursor(ScreenPtr pScr, CursorPtr pCurs);
1057   static void  ApmLoadCursorToCard(ScreenPtr pScr, CursorPtr pCurs, int x, int y);
1058 ***************
1059 *** 108,114 ****
1060    * This is also a local function, it's not called from outside.
1061    */
1062
1063 ! static void
1064   ApmHideCursor(void)
1065   {
1066     ApmCheckMMIO_Init();
1067 --- 108,114 ----
1068    * This is also a local function, it's not called from outside.
1069    */
1070
1071 ! void
1072   ApmHideCursor(void)
1073   {
1074     ApmCheckMMIO_Init();
1075 diff -c -N -r xc.old/programs/Xserver/hw/xfree86/vga256/drivers/apm/apm_driver.c ./hw/xfree86/vga256/drivers/apm/apm_driver.c
1076 *** xc.old/programs/Xserver/hw/xfree86/vga256/drivers/apm/apm_driver.c  Sun Feb 15 16:42:15 1998
1077 --- xc/programs/Xserver/hw/xfree86/vga256/drivers/apm/apm_driver.c      Sun Apr  4 18:13:42 1999
1078 ***************
1079 *** 610,616 ****
1080 --- 610,624 ----
1081
1082   #ifdef XFreeXDGA
1083     if (vga256InfoRec.directMode&XF86DGADirectGraphics && !enter)
1084 +   {
1085 +     if (vgaHWCursor.Initialized == TRUE)
1086 +     {
1087 +       extern void ApmHideCursor(void);
1088 +       ApmHideCursor();
1089 +     }
1090       return;
1091 +   }
1092 +
1093   #endif
1094
1095     if (enter)
1096 ***************
1097 *** 965,970 ****
1098 --- 973,985 ----
1099      */
1100     modinx(vgaIOBase + 4, 0x1c, 0x0f, (Base & 0x0f0000) >> 16);
1101
1102 + #ifdef XFreeXDGA
1103 +         if (vga256InfoRec.directMode & XF86DGADirectGraphics) {
1104 +                 /* Wait until vertical retrace is in progress. */
1105 +                 while (inb(vgaIOBase + 0xA) & 0x08);
1106 +                 while (!(inb(vgaIOBase + 0xA) & 0x08));
1107 +         }
1108 + #endif
1109   }
1110
1111   /*
1112 diff -c -N -r xc.old/programs/Xserver/hw/xfree86/xaa/xf86cparea.c ./hw/xfree86/xaa/xf86cparea.c
1113 *** xc.old/programs/Xserver/hw/xfree86/xaa/xf86cparea.c Mon Nov 18 05:22:11 1996
1114 --- xc/programs/Xserver/hw/xfree86/xaa/xf86cparea.c     Tue Apr  6 23:51:36 1999
1115 ***************
1116 *** 85,90 ****
1117 --- 85,92 ----
1118   #include      "xf86xaa.h"
1119   #include      "xf86local.h"
1120
1121 + #include      "xf86Priv.h"
1122 + #include      "xf86pcache.h"
1123
1124   RegionPtr
1125   xf86CopyArea(pSrcDrawable, pDstDrawable,
1126 ***************
1127 *** 96,105 ****
1128       int width, height;
1129       int dstx, dsty;
1130   {
1131 !     if (pSrcDrawable->type == DRAWABLE_WINDOW
1132 !     && pDstDrawable->type == DRAWABLE_WINDOW) {
1133           return (*xf86GCInfoRec.cfbBitBltDispatch)(
1134 !             pSrcDrawable, pDstDrawable,
1135               pGC, srcx, srcy, width, height, dstx, dsty,
1136               xf86DoBitBlt, 0L);
1137       }
1138 --- 98,110 ----
1139       int width, height;
1140       int dstx, dsty;
1141   {
1142 !     if ((pDstDrawable->type == DRAWABLE_WINDOW) &&
1143 !       ((pSrcDrawable->type == DRAWABLE_WINDOW) ||
1144 !       ((xf86AccelInfoRec.Flags & PIXMAP_CACHE) &&
1145 !        (pSrcDrawable->type == DRAWABLE_PIXMAP) &&
1146 !        xf86CacheIsLocked((PixmapPtr)pSrcDrawable)))) {
1147           return (*xf86GCInfoRec.cfbBitBltDispatch)(
1148 !           pSrcDrawable, pDstDrawable,
1149               pGC, srcx, srcy, width, height, dstx, dsty,
1150               xf86DoBitBlt, 0L);
1151       }
1152 ***************
1153 *** 132,137 ****
1154 --- 137,154 ----
1155       int xdir;                 /* 1 = left right, -1 = right left/ */
1156       int ydir;                 /* 1 = top down, -1 = bottom up */
1157       int careful;
1158 +     extern CacheInfoPtr xf86CacheInfo;
1159 +     int i, slot;
1160 +
1161 +     /* Handle locked pixmaps just like screen to screen blits */
1162 +     if (pSrc->type==DRAWABLE_PIXMAP) {
1163 +       slot=((xf86PixPrivPtr)((PixmapPtr)pSrc)->devPrivates[xf86PixmapIndex].ptr)->slot;
1164 +       pptTmp=pptSrc;
1165 +       for (i=0; i<REGION_NUM_RECTS(prgnDst); i++, pptTmp++) {
1166 +       pptTmp->x+=xf86CacheInfo[slot].x;
1167 +       pptTmp->y+=xf86CacheInfo[slot].y;
1168 +       }
1169 +     }
1170
1171       /* XXX we have to err on the side of safety when both are windows,
1172        * because we don't know if IncludeInferiors is being used.
1173 diff -c -N -r xc.old/programs/Xserver/hw/xfree86/xaa/xf86pcache.c ./hw/xfree86/xaa/xf86pcache.c
1174 *** xc.old/programs/Xserver/hw/xfree86/xaa/xf86pcache.c Sun Feb  8 07:36:25 1998
1175 --- xc/programs/Xserver/hw/xfree86/xaa/xf86pcache.c     Tue Apr 13 12:21:33 1999
1176 ***************
1177 *** 127,144 ****
1178
1179   CacheInfoPtr xf86CacheInfo = NULL;
1180   static int MaxSlot;
1181   static int MaxWidth;
1182   static int MaxHeight;
1183   static unsigned int pixmap_cache_clock = 1;
1184   static int FirstWideSlot;
1185   static int MaxWideSlotHeight;
1186
1187   void xf86InitPixmapCacheSlots()
1188   {
1189       ScrnInfoPtr infoRec;
1190       int memoryStart, memoryEnd;
1191 !     int width_in_bytes, cache_start_y, i;
1192 !     int height_left, standard_slots, wide_slots, wide_slot_width;
1193
1194       infoRec = xf86AccelInfoRec.ServerInfoRec;
1195       memoryStart = xf86AccelInfoRec.PixmapCacheMemoryStart;
1196 --- 127,147 ----
1197
1198   CacheInfoPtr xf86CacheInfo = NULL;
1199   static int MaxSlot;
1200 + static int MaxBigSlot;
1201   static int MaxWidth;
1202   static int MaxHeight;
1203   static unsigned int pixmap_cache_clock = 1;
1204   static int FirstWideSlot;
1205 + static int FirstBigSlot;
1206   static int MaxWideSlotHeight;
1207 + static int cache_start_y;
1208
1209   void xf86InitPixmapCacheSlots()
1210   {
1211       ScrnInfoPtr infoRec;
1212       int memoryStart, memoryEnd;
1213 !     int width_in_bytes, i;
1214 !     int height_left, standard_slots, wide_slots, wide_slot_width, big_slots;
1215
1216       infoRec = xf86AccelInfoRec.ServerInfoRec;
1217       memoryStart = xf86AccelInfoRec.PixmapCacheMemoryStart;
1218 ***************
1219 *** 228,236 ****
1220           }
1221       }
1222
1223       MaxSlot = standard_slots + wide_slots - 1;
1224 !     xf86CacheInfo = (CacheInfoPtr)xcalloc(MaxSlot + 1, sizeof(CacheInfo));
1225       FirstWideSlot = standard_slots;
1226
1227       ErrorF("%s %s: XAA: Using %d %dx%d ",
1228           XCONFIG_PROBED, infoRec->name, standard_slots, MaxWidth, MaxHeight);
1229 --- 231,243 ----
1230           }
1231       }
1232
1233 +     /* Arbitrarily say you can have 10 big slots */
1234 +     big_slots = 10;
1235       MaxSlot = standard_slots + wide_slots - 1;
1236 !     MaxBigSlot = MaxSlot + big_slots;
1237 !     xf86CacheInfo = (CacheInfoPtr)xcalloc(MaxBigSlot + 1, sizeof(CacheInfo));
1238       FirstWideSlot = standard_slots;
1239 +     FirstBigSlot = standard_slots + wide_slots;
1240
1241       ErrorF("%s %s: XAA: Using %d %dx%d ",
1242           XCONFIG_PROBED, infoRec->name, standard_slots, MaxWidth, MaxHeight);
1243 ***************
1244 *** 255,261 ****
1245           xf86CacheInfo[i + standard_slots].cache_height = min(32, height_left);
1246       }
1247
1248 !     for (i = 0; i <= MaxSlot; i++) {
1249           xf86CacheInfo[i].id = -1;
1250           xf86CacheInfo[i].lru = pixmap_cache_clock;
1251           xf86CacheInfo[i].fg_color = 0;
1252 --- 262,268 ----
1253           xf86CacheInfo[i + standard_slots].cache_height = min(32, height_left);
1254       }
1255
1256 !     for (i = 0; i <= MaxBigSlot; i++) {
1257           xf86CacheInfo[i].id = -1;
1258           xf86CacheInfo[i].lru = pixmap_cache_clock;
1259           xf86CacheInfo[i].fg_color = 0;
1260 ***************
1261 *** 315,321 ****
1262   #ifdef PIXPRIV
1263       devPriv = (xf86PixPrivPtr)(pix->devPrivates[xf86PixmapIndex].ptr);
1264
1265 !     if (devPriv->slot == MaxSlot + 1)
1266           /*
1267            * Special value indicates that this pattern was found to be
1268            * non-cachable.
1269 --- 322,328 ----
1270   #ifdef PIXPRIV
1271       devPriv = (xf86PixPrivPtr)(pix->devPrivates[xf86PixmapIndex].ptr);
1272
1273 !     if (devPriv->slot == MaxBigSlot + 1)
1274           /*
1275            * Special value indicates that this pattern was found to be
1276            * non-cachable.
1277 ***************
1278 *** 344,350 ****
1279                * pattern, but can't, and ScreenToScreencopy doesn't have
1280                * the required support for transparency.
1281                */
1282 !             devPriv->slot = MaxSlot + 1;
1283               return 0;
1284           }
1285           devPriv->slot = slot;
1286 --- 351,357 ----
1287                * pattern, but can't, and ScreenToScreencopy doesn't have
1288                * the required support for transparency.
1289                */
1290 !             devPriv->slot = MaxBigSlot + 1;
1291               return 0;
1292           }
1293           devPriv->slot = slot;
1294 ***************
1295 *** 893,898 ****
1296 --- 900,906 ----
1297       pci->flags = 0;
1298       pci->lru = pixmap_cache_clock;
1299       pci->id = pix->drawable.serialNumber;
1300 +     pci->locked = FALSE;
1301
1302       reducible_status = TILE_UNKNOWN;
1303
1304 ***************
1305 *** 1303,1305 ****
1306 --- 1311,1483 ----
1307      return (pix->drawable.width <= MaxWidth &&
1308          pix->drawable.height <= MaxHeight);
1309   }
1310 +
1311 + /* Rush extension support */
1312 +
1313 + int testOverlap(pcipix)
1314 +      CacheInfoPtr pcipix;
1315 + {
1316 +   int slot;
1317 +   CacheInfoPtr pcitest;
1318 +
1319 +   for (slot=FirstBigSlot; slot<=MaxBigSlot; slot++) {
1320 +     if (xf86CacheInfo[slot].id>0) {
1321 +       pcitest=&xf86CacheInfo[slot];
1322 +       if (!((pcipix->x+pcipix->w<pcitest->x ||
1323 +          pcipix->x>pcitest->x+pcitest->w) &&
1324 +         (pcipix->y+pcipix->h<pcitest->y ||
1325 +          pcipix->y>pcitest->y+pcitest->w)))
1326 +       return 1;
1327 +     }
1328 +   }
1329 +   return 0;
1330 + }
1331 +
1332 +
1333 + /*
1334 +   Dividing up the extra memory among X and Glide is difficult.
1335 +   We'll take what we're given and then try to stick up to big_slots
1336 +   pixmaps within it. big_slots should be small to keep this efficient.
1337 +   To fit the pixmap we'll try to put it next to and below each
1338 +   existing pixmap. Then we'll check if it overlaps anything.
1339 + */
1340 + static int
1341 + findPosition(pci, pix)
1342 +      CacheInfoPtr pci;
1343 +      PixmapPtr pix;
1344 + {
1345 +   int slot, bestx, besty;
1346 +
1347 +   bestx=-2;
1348 +   for (slot=FirstBigSlot; slot<=MaxBigSlot; slot++) {
1349 +     if (xf86CacheInfo[slot].id>0) {
1350 +       if (bestx==-2) bestx==-1;
1351 +       /* Check for fit to right */
1352 +       pci->x=xf86CacheInfo[slot].x+xf86CacheInfo[slot].w;
1353 +       pci->y=xf86CacheInfo[slot].y;
1354 +       if (bestx<0 || (bestx+besty>pci->x+pci->y)) {
1355 +       if (!testOverlap(pci, &xf86CacheInfo[slot])) {
1356 +         bestx=pci->x;
1357 +         besty=pci->y;
1358 +       }
1359 +       }
1360 +       /* Check for fit below */
1361 +       pci->x=xf86CacheInfo[slot].x;
1362 +       pci->y=xf86CacheInfo[slot].y+xf86CacheInfo[slot].h;
1363 +       if (bestx<0 || (bestx+besty>pci->x+pci->y)) {
1364 +       if (!testOverlap(pci, &xf86CacheInfo[slot])) {
1365 +         bestx=pci->x;
1366 +         besty=pci->y;
1367 +       }
1368 +       }
1369 +     }
1370 +   }
1371 +   if (bestx==-2) { /* Nothing in the list yet */
1372 +     bestx=0;
1373 +     besty=cache_start_y+MaxHeight;
1374 +   }
1375 +   if (bestx==-1) { /* Doesn't fit */
1376 +     return 0;
1377 +   }
1378 +   pci->x=bestx;
1379 +   pci->y=besty;
1380 + }
1381 +
1382 + void *
1383 + xf86LockPixmap(pix)
1384 +      PixmapPtr pix;
1385 + {
1386 +   xf86PixPrivPtr devPriv =
1387 +     (xf86PixPrivPtr)(pix->devPrivates[xf86PixmapIndex].ptr);
1388 +   int slot, size;
1389 +   ScrnInfoPtr infoRec;
1390 +   CacheInfoPtr pci;
1391 +
1392 +   switch (xf86AccelInfoRec.BitsPerPixel) {
1393 +   case 8:
1394 +     size=1;
1395 +     break;
1396 +   case 16:
1397 +     size=2;
1398 +     break;
1399 +   case 24:
1400 +     size=3;
1401 +     break;
1402 +   case 32:
1403 +     size=4;
1404 +     break;
1405 +   case 1:
1406 +   case 4:
1407 +   default:
1408 +     return 0;
1409 +   }
1410 +   for (slot=FirstBigSlot; slot<MaxBigSlot ; slot++) {
1411 +     if (slot==-1) break;
1412 +   }
1413 +   if (slot==MaxBigSlot) return 0;
1414 +   /* Assign the slot */
1415 +   IncrementCacheLRU(slot);
1416 +   devPriv->slot = slot;
1417 +   /* Fill in the cache entry */
1418 +   pci = &xf86CacheInfo[devPriv->slot];
1419 +   pci->pix_w = pix->drawable.width;
1420 +   pci->pix_h = pix->drawable.height;
1421 +   pci->nx = 1;
1422 +   pci->ny = 1;
1423 +   pci->w = pci->pix_w;
1424 +   pci->h = pci->pix_h;
1425 +   pci->fg_color = 0;
1426 +   pci->bg_color = 0;
1427 +   pci->flags = 0;
1428 +   pci->lru = pixmap_cache_clock;
1429 +   pci->locked = TRUE;
1430 +   /* Assign X & Y position */
1431 +   if (!findPosition(pci, pix)) return 0;
1432 +   pci->id = pix->drawable.serialNumber;
1433 +   xf86AccelInfoRec.ImageWrite(pci->x, pci->y, pci->pix_w, pci->pix_h,
1434 +                             pix->devPrivate.ptr, pix->devKind, GXcopy,
1435 +                             0xFFFFFFFF);
1436 +   infoRec=xf86AccelInfoRec.ServerInfoRec;
1437 +   return (void*)(infoRec->physBase +
1438 +                (xf86CacheInfo[slot].x +
1439 +                 xf86CacheInfo[slot].y*infoRec->displayWidth) * size);
1440 + }
1441 +
1442 + void
1443 + xf86UnlockPixmap(pix)
1444 +      PixmapPtr pix;
1445 + {
1446 +   xf86PixPrivPtr devPriv =
1447 +     (xf86PixPrivPtr)(pix->devPrivates[xf86PixmapIndex].ptr);
1448 +   if (devPriv->slot<0) return;
1449 +   xf86CacheInfo[devPriv->slot].locked = FALSE;
1450 +   xf86CacheInfo[devPriv->slot].id = -1;
1451 +   devPriv->slot = 0;
1452 + }
1453 +
1454 + void
1455 + xf86UnlockAllPixmaps()
1456 + {
1457 +   int i;
1458 +
1459 +   for (i=FirstBigSlot; i<=MaxBigSlot; i++) {
1460 +     if (xf86CacheInfo[i].id>0 && xf86CacheInfo[i].locked) {
1461 +       xf86CacheInfo[i].locked = FALSE;
1462 +       xf86CacheInfo[i].id = -1;
1463 +     }
1464 +   }
1465 + }
1466 +
1467 + int
1468 + xf86CacheIsLocked(pix)
1469 +      PixmapPtr pix;
1470 + {
1471 +   xf86PixPrivPtr devPriv =
1472 +     (xf86PixPrivPtr)(pix->devPrivates[xf86PixmapIndex].ptr);
1473 +   int slot;
1474 +
1475 +   slot=devPriv->slot;
1476 +   if (slot<FirstBigSlot || slot>MaxBigSlot) return 0;
1477 +   return xf86CacheInfo[slot].locked;
1478 + }
1479 +
1480 diff -c -N -r xc.old/programs/Xserver/hw/xfree86/xaa/xf86pcache.h ./hw/xfree86/xaa/xf86pcache.h
1481 *** xc.old/programs/Xserver/hw/xfree86/xaa/xf86pcache.h Fri Jan 17 22:57:28 1997
1482 --- xc/programs/Xserver/hw/xfree86/xaa/xf86pcache.h     Sun Apr  4 18:13:42 1999
1483 ***************
1484 *** 19,24 ****
1485 --- 19,25 ----
1486       int pattern0;       /* if fixed pattern, pattern 0 register contents */
1487       int pattern1;       /* if fixed pattern, pattern 1 register contents */
1488       unsigned int lru;   /* lru counter */
1489 +     Bool locked;
1490   } CacheInfo, *CacheInfoPtr;
1491
1492   #ifdef PIXPRIV
1493 ***************
1494 *** 43,45 ****
1495 --- 44,47 ----
1496   void xf86InitPixmapCacheSlots();
1497
1498   void xf86InvalidatePixmapCache();
1499 +
1500 diff -c -N -r xc.old/programs/Xserver/mi/Imakefile ./mi/Imakefile
1501 *** xc.old/programs/Xserver/mi/Imakefile        Sat May  3 02:50:45 1997
1502 --- xc/programs/Xserver/mi/Imakefile    Sun Apr  4 18:13:42 1999
1503 ***************
1504 *** 32,38 ****
1505    * Make sure XINPUT, XF86VidTune, etc aren't defined for the miinitext.o
1506    * used by Xnest, Xvfb
1507    */
1508 ! EXT_DEFINES = ExtensionDefines -UXINPUT -UXF86VIDMODE -UXFreeXDGA -UXF86MISC
1509   #else
1510   EXT_DEFINES = ExtensionDefines
1511   #endif
1512 --- 32,39 ----
1513    * Make sure XINPUT, XF86VidTune, etc aren't defined for the miinitext.o
1514    * used by Xnest, Xvfb
1515    */
1516 ! EXT_DEFINES = ExtensionDefines -UXINPUT -UXF86VIDMODE -UXFreeXDGA -UXF86MISC \
1517 !       -UXFreeXRUSH
1518   #else
1519   EXT_DEFINES = ExtensionDefines
1520   #endif
1521 diff -c -N -r xc.old/programs/Xserver/mi/miinitext.c ./mi/miinitext.c
1522 *** xc.old/programs/Xserver/mi/miinitext.c      Thu May 22 07:00:46 1997
1523 --- xc/programs/Xserver/mi/miinitext.c  Sun Apr  4 18:13:42 1999
1524 ***************
1525 *** 155,160 ****
1526 --- 155,163 ----
1527   #ifdef XFreeXDGA
1528   extern void XFree86DGAExtensionInit(INITARGS);
1529   #endif
1530 + #ifdef XFreeXRUSH
1531 + extern void XFree86RushExtensionInit(INITARGS);
1532 + #endif
1533   #ifdef DPMSExtension
1534   extern void DPMSExtensionInit(INITARGS);
1535   #endif
1536 ***************
1537 *** 264,269 ****
1538 --- 267,275 ----
1539   #endif
1540   #if defined(XFreeXDGA) && !defined(PRINT_ONLY_SERVER)
1541       XFree86DGAExtensionInit();
1542 + #endif
1543 + #if defined(XFreeXRUSH) && !defined(PRINT_ONLY_SERVER)
1544 +     XFree86RushExtensionInit();
1545   #endif
1546   #if defined(DPMSExtension) && !defined(PRINT_ONLY_SERVER)
1547       DPMSExtensionInit();