xorg-server-1.4/Xext/dpms.c

   1 /*****************************************************************
   2
   3 Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts.
   4
   5 Permission is hereby granted, free of charge, to any person obtaining a copy
   6 of this software and associated documentation files (the "Software"), to deal
   7 in the Software without restriction, including without limitation the rights
   8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 copies of the Software.
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
  18 BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
  19 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
  20 IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22 Except as contained in this notice, the name of Digital Equipment Corporation
  23 shall not be used in advertising or otherwise to promote the sale, use or other
  24 dealings in this Software without prior written authorization from Digital
  25 Equipment Corporation.
  26
  27 ******************************************************************/
  28
  29 /*
  30  * HISTORY
  31  *
  32  * @(#)RCSfile: dpms.c,v Revision: 1.1.4.5  (DEC) Date: 1996/03/04 15:27:00
  33  */
  34
  35
  36 #ifdef HAVE_DIX_CONFIG_H
  37 #include <dix-config.h>
  38 #endif
  39
  40 #include <X11/X.h>
  41 #include <X11/Xproto.h>
  42 #include "misc.h"
  43 #include "os.h"
  44 #include "dixstruct.h"
  45 #include "extnsionst.h"
  46 #include "opaque.h"
  47 #define DPMS_SERVER
  48 #include <X11/extensions/dpms.h>
  49 #include <X11/extensions/dpmsstr.h>
  50 #include "dpmsproc.h"
  51 #include "modinit.h"
  52
  53 #if 0
  54 static unsigned char DPMSCode;
  55 #endif
  56 static DISPATCH_PROC(ProcDPMSDispatch);
  57 static DISPATCH_PROC(SProcDPMSDispatch);
  58 static DISPATCH_PROC(ProcDPMSGetVersion);
  59 static DISPATCH_PROC(SProcDPMSGetVersion);
  60 static DISPATCH_PROC(ProcDPMSGetTimeouts);
  61 static DISPATCH_PROC(SProcDPMSGetTimeouts);
  62 static DISPATCH_PROC(ProcDPMSSetTimeouts);
  63 static DISPATCH_PROC(SProcDPMSSetTimeouts);
  64 static DISPATCH_PROC(ProcDPMSEnable);
  65 static DISPATCH_PROC(SProcDPMSEnable);
  66 static DISPATCH_PROC(ProcDPMSDisable);
  67 static DISPATCH_PROC(SProcDPMSDisable);
  68 static DISPATCH_PROC(ProcDPMSForceLevel);
  69 static DISPATCH_PROC(SProcDPMSForceLevel);
  70 static DISPATCH_PROC(ProcDPMSInfo);
  71 static DISPATCH_PROC(SProcDPMSInfo);
  72 static DISPATCH_PROC(ProcDPMSCapable);
  73 static DISPATCH_PROC(SProcDPMSCapable);
  74 static void DPMSResetProc(ExtensionEntry* extEntry);
  75
  76 void
  77 DPMSExtensionInit(INITARGS)
  78 {
  79 #if 0
  80     ExtensionEntry *extEntry;
  81
  82     if ((extEntry = AddExtension(DPMSExtensionName, 0, 0,
  83                                 ProcDPMSDispatch, SProcDPMSDispatch,
  84                                 DPMSResetProc, StandardMinorOpcode)))
  85         DPMSCode = (unsigned char)extEntry->base;
  86 #else
  87     (void) AddExtension(DPMSExtensionName, 0, 0,
  88                         ProcDPMSDispatch, SProcDPMSDispatch,
  89                         DPMSResetProc, StandardMinorOpcode);
  90 #endif
  91 }
  92
  93 /*ARGSUSED*/
  94 static void
  95 DPMSResetProc (extEntry)
  96     ExtensionEntry      *extEntry;
  97 {
  98 }
  99
 100 static int
 101 ProcDPMSGetVersion(client)
 102     register ClientPtr client;
 103 {
 104     /* REQUEST(xDPMSGetVersionReq); */
 105     xDPMSGetVersionReply rep;
 106     register int n;
 107
 108     REQUEST_SIZE_MATCH(xDPMSGetVersionReq);
 109
 110     rep.type = X_Reply;
 111     rep.length = 0;
 112     rep.sequenceNumber = client->sequence;
 113     rep.majorVersion = DPMSMajorVersion;
 114     rep.minorVersion = DPMSMinorVersion;
 115     if (client->swapped) {
 116         swaps(&rep.sequenceNumber, n);
 117         swaps(&rep.majorVersion, n);
 118         swaps(&rep.minorVersion, n);
 119     }
 120     WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *)&rep);
 121     return(client->noClientException);
 122 }
 123
 124 static int
 125 ProcDPMSCapable(register ClientPtr client)
 126 {
 127     /* REQUEST(xDPMSCapableReq); */
 128     xDPMSCapableReply rep;
 129     register int n;
 130
 131     REQUEST_SIZE_MATCH(xDPMSCapableReq);
 132
 133     rep.type = X_Reply;
 134     rep.length = 0;
 135     rep.sequenceNumber = client->sequence;
 136     rep.capable = DPMSCapableFlag;
 137
 138     if (client->swapped) {
 139         swaps(&rep.sequenceNumber, n);
 140     }
 141     WriteToClient(client, sizeof(xDPMSCapableReply), (char *)&rep);
 142     return(client->noClientException);
 143 }
 144
 145 static int
 146 ProcDPMSGetTimeouts(client)
 147     register ClientPtr client;
 148 {
 149     /* REQUEST(xDPMSGetTimeoutsReq); */
 150     xDPMSGetTimeoutsReply rep;
 151     register int n;
 152
 153     REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);
 154
 155     rep.type = X_Reply;
 156     rep.length = 0;
 157     rep.sequenceNumber = client->sequence;
 158     rep.standby = DPMSStandbyTime / MILLI_PER_SECOND;
 159     rep.suspend = DPMSSuspendTime / MILLI_PER_SECOND;
 160     rep.off = DPMSOffTime / MILLI_PER_SECOND;
 161
 162     if (client->swapped) {
 163         swaps(&rep.sequenceNumber, n);
 164         swaps(&rep.standby, n);
 165         swaps(&rep.suspend, n);
 166         swaps(&rep.off, n);
 167     }
 168     WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *)&rep);
 169     return(client->noClientException);
 170 }
 171
 172 static int
 173 ProcDPMSSetTimeouts(client)
 174     register ClientPtr client;
 175 {
 176     REQUEST(xDPMSSetTimeoutsReq);
 177
 178     REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
 179
 180     if ((stuff->off != 0)&&(stuff->off < stuff->suspend))
 181     {
 182         client->errorValue = stuff->off;
 183         return BadValue;
 184     }
 185     if ((stuff->suspend != 0)&&(stuff->suspend < stuff->standby))
 186     {
 187         client->errorValue = stuff->suspend;
 188         return BadValue;
 189     }
 190
 191     DPMSStandbyTime = stuff->standby * MILLI_PER_SECOND;
 192     DPMSSuspendTime = stuff->suspend * MILLI_PER_SECOND;
 193     DPMSOffTime = stuff->off * MILLI_PER_SECOND;
 194     SetScreenSaverTimer();
 195
 196     return(client->noClientException);
 197 }
 198
 199 static int
 200 ProcDPMSEnable(client)
 201     register ClientPtr client;
 202 {
 203     /* REQUEST(xDPMSEnableReq); */
 204
 205     REQUEST_SIZE_MATCH(xDPMSEnableReq);
 206
 207     if (DPMSCapableFlag)
 208         DPMSEnabled = TRUE;
 209
 210     return(client->noClientException);
 211 }
 212
 213 static int
 214 ProcDPMSDisable(client)
 215     register ClientPtr client;
 216 {
 217     /* REQUEST(xDPMSDisableReq); */
 218
 219     REQUEST_SIZE_MATCH(xDPMSDisableReq);
 220
 221     DPMSSet(DPMSModeOn);
 222
 223     DPMSEnabled = FALSE;
 224
 225     return(client->noClientException);
 226 }
 227
 228 static int
 229 ProcDPMSForceLevel(client)
 230     register ClientPtr client;
 231 {
 232     REQUEST(xDPMSForceLevelReq);
 233
 234     REQUEST_SIZE_MATCH(xDPMSForceLevelReq);
 235
 236     if (!DPMSEnabled)
 237         return BadMatch;
 238
 239     if (stuff->level == DPMSModeOn) {
 240       lastDeviceEventTime.milliseconds =
 241           GetTimeInMillis();
 242     } else if (stuff->level == DPMSModeStandby) {
 243       lastDeviceEventTime.milliseconds =
 244           GetTimeInMillis() -  DPMSStandbyTime;
 245     } else if (stuff->level == DPMSModeSuspend) {
 246       lastDeviceEventTime.milliseconds =
 247           GetTimeInMillis() -  DPMSSuspendTime;
 248     } else if (stuff->level == DPMSModeOff) {
 249       lastDeviceEventTime.milliseconds =
 250           GetTimeInMillis() -  DPMSOffTime;
 251     } else {
 252         client->errorValue = stuff->level;
 253         return BadValue;
 254     }
 255
 256     DPMSSet(stuff->level);
 257
 258     return(client->noClientException);
 259 }
 260
 261 static int
 262 ProcDPMSInfo(register ClientPtr client)
 263 {
 264     /* REQUEST(xDPMSInfoReq); */
 265     xDPMSInfoReply rep;
 266     register int n;
 267
 268     REQUEST_SIZE_MATCH(xDPMSInfoReq);
 269
 270     rep.type = X_Reply;
 271     rep.length = 0;
 272     rep.sequenceNumber = client->sequence;
 273     rep.power_level = DPMSPowerLevel;
 274     rep.state = DPMSEnabled;
 275
 276     if (client->swapped) {
 277         swaps(&rep.sequenceNumber, n);
 278         swaps(&rep.power_level, n);
 279     }
 280     WriteToClient(client, sizeof(xDPMSInfoReply), (char *)&rep);
 281     return(client->noClientException);
 282 }
 283
 284 static int
 285 ProcDPMSDispatch (client)
 286     register ClientPtr  client;
 287 {
 288     REQUEST(xReq);
 289
 290     switch (stuff->data)
 291     {
 292     case X_DPMSGetVersion:
 293         return ProcDPMSGetVersion(client);
 294     case X_DPMSCapable:
 295         return ProcDPMSCapable(client);
 296     case X_DPMSGetTimeouts:
 297         return ProcDPMSGetTimeouts(client);
 298     case X_DPMSSetTimeouts:
 299         return ProcDPMSSetTimeouts(client);
 300     case X_DPMSEnable:
 301         return ProcDPMSEnable(client);
 302     case X_DPMSDisable:
 303         return ProcDPMSDisable(client);
 304     case X_DPMSForceLevel:
 305         return ProcDPMSForceLevel(client);
 306     case X_DPMSInfo:
 307         return ProcDPMSInfo(client);
 308     default:
 309         return BadRequest;
 310     }
 311 }
 312
 313 static int
 314 SProcDPMSGetVersion(client)
 315     register ClientPtr  client;
 316 {
 317     register int n;
 318     REQUEST(xDPMSGetVersionReq);
 319
 320     swaps(&stuff->length, n);
 321     REQUEST_SIZE_MATCH(xDPMSGetVersionReq);
 322     swaps(&stuff->majorVersion, n);
 323     swaps(&stuff->minorVersion, n);
 324     return ProcDPMSGetVersion(client);
 325 }
 326
 327 static int
 328 SProcDPMSCapable(register ClientPtr client)
 329 {
 330     REQUEST(xDPMSCapableReq);
 331     register int n;
 332
 333     swaps(&stuff->length, n);
 334     REQUEST_SIZE_MATCH(xDPMSCapableReq);
 335
 336     return ProcDPMSCapable(client);
 337 }
 338
 339 static int
 340 SProcDPMSGetTimeouts(client)
 341     register ClientPtr client;
 342 {
 343     REQUEST(xDPMSGetTimeoutsReq);
 344     register int n;
 345
 346     swaps(&stuff->length, n);
 347     REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);
 348
 349     return ProcDPMSGetTimeouts(client);
 350 }
 351
 352 static int
 353 SProcDPMSSetTimeouts(client)
 354     register ClientPtr client;
 355 {
 356     REQUEST(xDPMSSetTimeoutsReq);
 357     register int n;
 358
 359     swaps(&stuff->length, n);
 360     REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
 361
 362     swaps(&stuff->standby, n);
 363     swaps(&stuff->suspend, n);
 364     swaps(&stuff->off, n);
 365     return ProcDPMSSetTimeouts(client);
 366 }
 367
 368 static int
 369 SProcDPMSEnable(client)
 370     register ClientPtr client;
 371 {
 372     REQUEST(xDPMSEnableReq);
 373     register int n;
 374
 375     swaps(&stuff->length, n);
 376     REQUEST_SIZE_MATCH(xDPMSEnableReq);
 377
 378     return ProcDPMSEnable(client);
 379 }
 380
 381 static int
 382 SProcDPMSDisable(client)
 383     register ClientPtr client;
 384 {
 385     REQUEST(xDPMSDisableReq);
 386     register int n;
 387
 388     swaps(&stuff->length, n);
 389     REQUEST_SIZE_MATCH(xDPMSDisableReq);
 390
 391     return ProcDPMSDisable(client);
 392 }
 393
 394 static int
 395 SProcDPMSForceLevel(client)
 396     register ClientPtr client;
 397 {
 398     REQUEST(xDPMSForceLevelReq);
 399     register int n;
 400
 401     swaps(&stuff->length, n);
 402     REQUEST_SIZE_MATCH(xDPMSForceLevelReq);
 403
 404     swaps(&stuff->level, n);
 405
 406     return ProcDPMSForceLevel(client);
 407 }
 408
 409 static int
 410 SProcDPMSInfo(client)
 411     register ClientPtr client;
 412 {
 413     REQUEST(xDPMSInfoReq);
 414     register int n;
 415
 416     swaps(&stuff->length, n);
 417     REQUEST_SIZE_MATCH(xDPMSInfoReq);
 418
 419     return ProcDPMSInfo(client);
 420 }
 421
 422 static int
 423 SProcDPMSDispatch (client)
 424     register ClientPtr  client;
 425 {
 426     REQUEST(xReq);
 427     switch (stuff->data)
 428     {
 429     case X_DPMSGetVersion:
 430         return SProcDPMSGetVersion(client);
 431     case X_DPMSCapable:
 432         return SProcDPMSCapable(client);
 433     case X_DPMSGetTimeouts:
 434         return SProcDPMSGetTimeouts(client);
 435     case X_DPMSSetTimeouts:
 436         return SProcDPMSSetTimeouts(client);
 437     case X_DPMSEnable:
 438         return SProcDPMSEnable(client);
 439     case X_DPMSDisable:
 440         return SProcDPMSDisable(client);
 441     case X_DPMSForceLevel:
 442         return SProcDPMSForceLevel(client);
 443     case X_DPMSInfo:
 444         return SProcDPMSInfo(client);
 445     default:
 446         return BadRequest;
 447     }
 448 }