vidmode.c (68871B)
1 /* 2 3 Copyright 1995 Kaleb S. KEITHLEY 4 5 Permission is hereby granted, free of charge, to any person obtaining 6 a copy of this software and associated documentation files (the 7 "Software"), to deal in the Software without restriction, including 8 without limitation the rights to use, copy, modify, merge, publish, 9 distribute, sublicense, and/or sell copies of the Software, and to 10 permit persons to whom the Software is furnished to do so, subject to 11 the following conditions: 12 13 The above copyright notice and this permission notice shall be 14 included in all copies or substantial portions of the Software. 15 16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES 20 OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 OTHER DEALINGS IN THE SOFTWARE. 23 24 Except as contained in this notice, the name of Kaleb S. KEITHLEY 25 shall not be used in advertising or otherwise to promote the sale, use 26 or other dealings in this Software without prior written authorization 27 from Kaleb S. KEITHLEY 28 29 */ 30 /* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */ 31 32 #ifdef HAVE_DIX_CONFIG_H 33 #include <dix-config.h> 34 #endif 35 36 #ifdef XF86VIDMODE 37 38 #include <X11/X.h> 39 #include <X11/Xproto.h> 40 #include <X11/extensions/xf86vmproto.h> 41 #include "misc.h" 42 #include "dixstruct.h" 43 #include "extnsionst.h" 44 #include "scrnintstr.h" 45 #include "servermd.h" 46 #include "swaprep.h" 47 #include "vidmodestr.h" 48 #include "globals.h" 49 #include "protocol-versions.h" 50 51 static int VidModeErrorBase; 52 static int VidModeAllowNonLocal; 53 54 static DevPrivateKeyRec VidModeClientPrivateKeyRec; 55 #define VidModeClientPrivateKey (&VidModeClientPrivateKeyRec) 56 57 static DevPrivateKeyRec VidModePrivateKeyRec; 58 #define VidModePrivateKey (&VidModePrivateKeyRec) 59 60 /* This holds the client's version information */ 61 typedef struct { 62 int major; 63 int minor; 64 } VidModePrivRec, *VidModePrivPtr; 65 66 #define VM_GETPRIV(c) ((VidModePrivPtr) \ 67 dixLookupPrivate(&(c)->devPrivates, VidModeClientPrivateKey)) 68 #define VM_SETPRIV(c,p) \ 69 dixSetPrivate(&(c)->devPrivates, VidModeClientPrivateKey, p) 70 71 #ifdef DEBUG 72 #define DEBUG_P(x) DebugF(x"\n") 73 #else 74 #define DEBUG_P(x) /**/ 75 #endif 76 77 static DisplayModePtr 78 VidModeCreateMode(void) 79 { 80 DisplayModePtr mode; 81 82 mode = malloc(sizeof(DisplayModeRec)); 83 if (mode != NULL) { 84 mode->name = ""; 85 mode->VScan = 1; /* divides refresh rate. default = 1 */ 86 mode->Private = NULL; 87 mode->next = mode; 88 mode->prev = mode; 89 } 90 return mode; 91 } 92 93 static void 94 VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto) 95 { 96 memcpy(modeto, modefrom, sizeof(DisplayModeRec)); 97 } 98 99 static int 100 VidModeGetModeValue(DisplayModePtr mode, int valtyp) 101 { 102 int ret = 0; 103 104 switch (valtyp) { 105 case VIDMODE_H_DISPLAY: 106 ret = mode->HDisplay; 107 break; 108 case VIDMODE_H_SYNCSTART: 109 ret = mode->HSyncStart; 110 break; 111 case VIDMODE_H_SYNCEND: 112 ret = mode->HSyncEnd; 113 break; 114 case VIDMODE_H_TOTAL: 115 ret = mode->HTotal; 116 break; 117 case VIDMODE_H_SKEW: 118 ret = mode->HSkew; 119 break; 120 case VIDMODE_V_DISPLAY: 121 ret = mode->VDisplay; 122 break; 123 case VIDMODE_V_SYNCSTART: 124 ret = mode->VSyncStart; 125 break; 126 case VIDMODE_V_SYNCEND: 127 ret = mode->VSyncEnd; 128 break; 129 case VIDMODE_V_TOTAL: 130 ret = mode->VTotal; 131 break; 132 case VIDMODE_FLAGS: 133 ret = mode->Flags; 134 break; 135 case VIDMODE_CLOCK: 136 ret = mode->Clock; 137 break; 138 } 139 return ret; 140 } 141 142 static void 143 VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val) 144 { 145 switch (valtyp) { 146 case VIDMODE_H_DISPLAY: 147 mode->HDisplay = val; 148 break; 149 case VIDMODE_H_SYNCSTART: 150 mode->HSyncStart = val; 151 break; 152 case VIDMODE_H_SYNCEND: 153 mode->HSyncEnd = val; 154 break; 155 case VIDMODE_H_TOTAL: 156 mode->HTotal = val; 157 break; 158 case VIDMODE_H_SKEW: 159 mode->HSkew = val; 160 break; 161 case VIDMODE_V_DISPLAY: 162 mode->VDisplay = val; 163 break; 164 case VIDMODE_V_SYNCSTART: 165 mode->VSyncStart = val; 166 break; 167 case VIDMODE_V_SYNCEND: 168 mode->VSyncEnd = val; 169 break; 170 case VIDMODE_V_TOTAL: 171 mode->VTotal = val; 172 break; 173 case VIDMODE_FLAGS: 174 mode->Flags = val; 175 break; 176 case VIDMODE_CLOCK: 177 mode->Clock = val; 178 break; 179 } 180 return; 181 } 182 183 static int 184 ClientMajorVersion(ClientPtr client) 185 { 186 VidModePrivPtr pPriv; 187 188 pPriv = VM_GETPRIV(client); 189 if (!pPriv) 190 return 0; 191 else 192 return pPriv->major; 193 } 194 195 static int 196 ProcVidModeQueryVersion(ClientPtr client) 197 { 198 xXF86VidModeQueryVersionReply rep = { 199 .type = X_Reply, 200 .sequenceNumber = client->sequence, 201 .length = 0, 202 .majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION, 203 .minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION 204 }; 205 206 DEBUG_P("XF86VidModeQueryVersion"); 207 208 REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq); 209 210 if (client->swapped) { 211 swaps(&rep.sequenceNumber); 212 swapl(&rep.length); 213 swaps(&rep.majorVersion); 214 swaps(&rep.minorVersion); 215 } 216 WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), &rep); 217 return Success; 218 } 219 220 static int 221 ProcVidModeGetModeLine(ClientPtr client) 222 { 223 REQUEST(xXF86VidModeGetModeLineReq); 224 xXF86VidModeGetModeLineReply rep = { 225 .type = X_Reply, 226 .sequenceNumber = client->sequence 227 }; 228 ScreenPtr pScreen; 229 VidModePtr pVidMode; 230 DisplayModePtr mode; 231 int dotClock; 232 int ver; 233 234 DEBUG_P("XF86VidModeGetModeline"); 235 236 ver = ClientMajorVersion(client); 237 REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq); 238 239 if (ver < 2) { 240 rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply) - 241 SIZEOF(xGenericReply)); 242 } 243 else { 244 rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetModeLineReply) - 245 SIZEOF(xGenericReply)); 246 } 247 248 if (stuff->screen >= screenInfo.numScreens) 249 return BadValue; 250 pScreen = screenInfo.screens[stuff->screen]; 251 pVidMode = VidModeGetPtr(pScreen); 252 if (pVidMode == NULL) 253 return BadImplementation; 254 255 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock)) 256 return BadValue; 257 258 rep.dotclock = dotClock; 259 rep.hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY); 260 rep.hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART); 261 rep.hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND); 262 rep.htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL); 263 rep.hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW); 264 rep.vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY); 265 rep.vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART); 266 rep.vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND); 267 rep.vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL); 268 rep.flags = VidModeGetModeValue(mode, VIDMODE_FLAGS); 269 270 DebugF("GetModeLine - scrn: %d clock: %ld\n", 271 stuff->screen, (unsigned long) rep.dotclock); 272 DebugF("GetModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n", 273 rep.hdisplay, rep.hsyncstart, rep.hsyncend, rep.htotal); 274 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", 275 rep.vdisplay, rep.vsyncstart, rep.vsyncend, 276 rep.vtotal, (unsigned long) rep.flags); 277 278 /* 279 * Older servers sometimes had server privates that the VidMode 280 * extension made available. So to be compatible pretend that 281 * there are no server privates to pass to the client. 282 */ 283 rep.privsize = 0; 284 285 if (client->swapped) { 286 swaps(&rep.sequenceNumber); 287 swapl(&rep.length); 288 swapl(&rep.dotclock); 289 swaps(&rep.hdisplay); 290 swaps(&rep.hsyncstart); 291 swaps(&rep.hsyncend); 292 swaps(&rep.htotal); 293 swaps(&rep.hskew); 294 swaps(&rep.vdisplay); 295 swaps(&rep.vsyncstart); 296 swaps(&rep.vsyncend); 297 swaps(&rep.vtotal); 298 swapl(&rep.flags); 299 swapl(&rep.privsize); 300 } 301 if (ver < 2) { 302 xXF86OldVidModeGetModeLineReply oldrep = { 303 .type = rep.type, 304 .sequenceNumber = rep.sequenceNumber, 305 .length = rep.length, 306 .dotclock = rep.dotclock, 307 .hdisplay = rep.hdisplay, 308 .hsyncstart = rep.hsyncstart, 309 .hsyncend = rep.hsyncend, 310 .htotal = rep.htotal, 311 .vdisplay = rep.vdisplay, 312 .vsyncstart = rep.vsyncstart, 313 .vsyncend = rep.vsyncend, 314 .vtotal = rep.vtotal, 315 .flags = rep.flags, 316 .privsize = rep.privsize 317 }; 318 WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply), &oldrep); 319 } 320 else { 321 WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), &rep); 322 } 323 return Success; 324 } 325 326 static int 327 ProcVidModeGetAllModeLines(ClientPtr client) 328 { 329 REQUEST(xXF86VidModeGetAllModeLinesReq); 330 xXF86VidModeGetAllModeLinesReply rep; 331 ScreenPtr pScreen; 332 VidModePtr pVidMode; 333 DisplayModePtr mode; 334 int modecount, dotClock; 335 int ver; 336 337 DEBUG_P("XF86VidModeGetAllModelines"); 338 339 REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq); 340 341 if (stuff->screen >= screenInfo.numScreens) 342 return BadValue; 343 pScreen = screenInfo.screens[stuff->screen]; 344 ver = ClientMajorVersion(client); 345 pVidMode = VidModeGetPtr(pScreen); 346 if (pVidMode == NULL) 347 return BadImplementation; 348 349 modecount = pVidMode->GetNumOfModes(pScreen); 350 if (modecount < 1) 351 return VidModeErrorBase + XF86VidModeExtensionDisabled; 352 353 if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock)) 354 return BadValue; 355 356 rep = (xXF86VidModeGetAllModeLinesReply) { 357 .type = X_Reply, 358 .length = SIZEOF(xXF86VidModeGetAllModeLinesReply) - 359 SIZEOF(xGenericReply), 360 .sequenceNumber = client->sequence, 361 .modecount = modecount 362 }; 363 if (ver < 2) 364 rep.length += modecount * sizeof(xXF86OldVidModeModeInfo); 365 else 366 rep.length += modecount * sizeof(xXF86VidModeModeInfo); 367 rep.length >>= 2; 368 if (client->swapped) { 369 swaps(&rep.sequenceNumber); 370 swapl(&rep.length); 371 swapl(&rep.modecount); 372 } 373 WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), &rep); 374 375 do { 376 xXF86VidModeModeInfo mdinf = { 377 .dotclock = dotClock, 378 .hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY), 379 .hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART), 380 .hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND), 381 .htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL), 382 .hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW), 383 .vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY), 384 .vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART), 385 .vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND), 386 .vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL), 387 .flags = VidModeGetModeValue(mode, VIDMODE_FLAGS), 388 .privsize = 0 389 }; 390 if (client->swapped) { 391 swapl(&mdinf.dotclock); 392 swaps(&mdinf.hdisplay); 393 swaps(&mdinf.hsyncstart); 394 swaps(&mdinf.hsyncend); 395 swaps(&mdinf.htotal); 396 swapl(&mdinf.hskew); 397 swaps(&mdinf.vdisplay); 398 swaps(&mdinf.vsyncstart); 399 swaps(&mdinf.vsyncend); 400 swaps(&mdinf.vtotal); 401 swapl(&mdinf.flags); 402 swapl(&mdinf.privsize); 403 } 404 if (ver < 2) { 405 xXF86OldVidModeModeInfo oldmdinf = { 406 .dotclock = mdinf.dotclock, 407 .hdisplay = mdinf.hdisplay, 408 .hsyncstart = mdinf.hsyncstart, 409 .hsyncend = mdinf.hsyncend, 410 .htotal = mdinf.htotal, 411 .vdisplay = mdinf.vdisplay, 412 .vsyncstart = mdinf.vsyncstart, 413 .vsyncend = mdinf.vsyncend, 414 .vtotal = mdinf.vtotal, 415 .flags = mdinf.flags, 416 .privsize = mdinf.privsize 417 }; 418 WriteToClient(client, sizeof(xXF86OldVidModeModeInfo), &oldmdinf); 419 } 420 else { 421 WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf); 422 } 423 424 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock)); 425 426 return Success; 427 } 428 429 #define MODEMATCH(mode,stuff) \ 430 (VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay \ 431 && VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) == stuff->hsyncstart \ 432 && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND) == stuff->hsyncend \ 433 && VidModeGetModeValue(mode, VIDMODE_H_TOTAL) == stuff->htotal \ 434 && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY) == stuff->vdisplay \ 435 && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART) == stuff->vsyncstart \ 436 && VidModeGetModeValue(mode, VIDMODE_V_SYNCEND) == stuff->vsyncend \ 437 && VidModeGetModeValue(mode, VIDMODE_V_TOTAL) == stuff->vtotal \ 438 && VidModeGetModeValue(mode, VIDMODE_FLAGS) == stuff->flags ) 439 440 static int 441 ProcVidModeAddModeLine(ClientPtr client) 442 { 443 REQUEST(xXF86VidModeAddModeLineReq); 444 xXF86OldVidModeAddModeLineReq *oldstuff = 445 (xXF86OldVidModeAddModeLineReq *) client->requestBuffer; 446 xXF86VidModeAddModeLineReq newstuff; 447 ScreenPtr pScreen; 448 VidModePtr pVidMode; 449 DisplayModePtr mode; 450 int len; 451 int dotClock; 452 int ver; 453 454 DEBUG_P("XF86VidModeAddModeline"); 455 456 ver = ClientMajorVersion(client); 457 458 if (ver < 2) { 459 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq); 460 len = 461 client->req_len - 462 bytes_to_int32(sizeof(xXF86OldVidModeAddModeLineReq)); 463 } 464 else { 465 REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq); 466 len = 467 client->req_len - 468 bytes_to_int32(sizeof(xXF86VidModeAddModeLineReq)); 469 } 470 471 if (ver < 2) { 472 /* convert from old format */ 473 stuff = &newstuff; 474 stuff->length = oldstuff->length; 475 stuff->screen = oldstuff->screen; 476 stuff->dotclock = oldstuff->dotclock; 477 stuff->hdisplay = oldstuff->hdisplay; 478 stuff->hsyncstart = oldstuff->hsyncstart; 479 stuff->hsyncend = oldstuff->hsyncend; 480 stuff->htotal = oldstuff->htotal; 481 stuff->hskew = 0; 482 stuff->vdisplay = oldstuff->vdisplay; 483 stuff->vsyncstart = oldstuff->vsyncstart; 484 stuff->vsyncend = oldstuff->vsyncend; 485 stuff->vtotal = oldstuff->vtotal; 486 stuff->flags = oldstuff->flags; 487 stuff->privsize = oldstuff->privsize; 488 stuff->after_dotclock = oldstuff->after_dotclock; 489 stuff->after_hdisplay = oldstuff->after_hdisplay; 490 stuff->after_hsyncstart = oldstuff->after_hsyncstart; 491 stuff->after_hsyncend = oldstuff->after_hsyncend; 492 stuff->after_htotal = oldstuff->after_htotal; 493 stuff->after_hskew = 0; 494 stuff->after_vdisplay = oldstuff->after_vdisplay; 495 stuff->after_vsyncstart = oldstuff->after_vsyncstart; 496 stuff->after_vsyncend = oldstuff->after_vsyncend; 497 stuff->after_vtotal = oldstuff->after_vtotal; 498 stuff->after_flags = oldstuff->after_flags; 499 } 500 DebugF("AddModeLine - scrn: %d clock: %ld\n", 501 (int) stuff->screen, (unsigned long) stuff->dotclock); 502 DebugF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n", 503 stuff->hdisplay, stuff->hsyncstart, 504 stuff->hsyncend, stuff->htotal); 505 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", 506 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, 507 stuff->vtotal, (unsigned long) stuff->flags); 508 DebugF(" after - scrn: %d clock: %ld\n", 509 (int) stuff->screen, (unsigned long) stuff->after_dotclock); 510 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", 511 stuff->after_hdisplay, stuff->after_hsyncstart, 512 stuff->after_hsyncend, stuff->after_htotal); 513 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", 514 stuff->after_vdisplay, stuff->after_vsyncstart, 515 stuff->after_vsyncend, stuff->after_vtotal, 516 (unsigned long) stuff->after_flags); 517 518 if (len != stuff->privsize) 519 return BadLength; 520 521 if (stuff->screen >= screenInfo.numScreens) 522 return BadValue; 523 pScreen = screenInfo.screens[stuff->screen]; 524 525 if (stuff->hsyncstart < stuff->hdisplay || 526 stuff->hsyncend < stuff->hsyncstart || 527 stuff->htotal < stuff->hsyncend || 528 stuff->vsyncstart < stuff->vdisplay || 529 stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend) 530 return BadValue; 531 532 if (stuff->after_hsyncstart < stuff->after_hdisplay || 533 stuff->after_hsyncend < stuff->after_hsyncstart || 534 stuff->after_htotal < stuff->after_hsyncend || 535 stuff->after_vsyncstart < stuff->after_vdisplay || 536 stuff->after_vsyncend < stuff->after_vsyncstart || 537 stuff->after_vtotal < stuff->after_vsyncend) 538 return BadValue; 539 540 pVidMode = VidModeGetPtr(pScreen); 541 if (pVidMode == NULL) 542 return BadImplementation; 543 544 if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) { 545 Bool found = FALSE; 546 547 if (pVidMode->GetFirstModeline(pScreen, &mode, &dotClock)) { 548 do { 549 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) 550 == dotClock) && MODEMATCH(mode, stuff)) { 551 found = TRUE; 552 break; 553 } 554 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock)); 555 } 556 if (!found) 557 return BadValue; 558 } 559 560 mode = VidModeCreateMode(); 561 if (mode == NULL) 562 return BadValue; 563 564 VidModeSetModeValue(mode, VIDMODE_CLOCK, stuff->dotclock); 565 VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay); 566 VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart); 567 VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend); 568 VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal); 569 VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew); 570 VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay); 571 VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart); 572 VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend); 573 VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal); 574 VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags); 575 576 if (stuff->privsize) 577 DebugF("AddModeLine - Privates in request have been ignored\n"); 578 579 /* Check that the mode is consistent with the monitor specs */ 580 switch (pVidMode->CheckModeForMonitor(pScreen, mode)) { 581 case MODE_OK: 582 break; 583 case MODE_HSYNC: 584 case MODE_H_ILLEGAL: 585 free(mode); 586 return VidModeErrorBase + XF86VidModeBadHTimings; 587 case MODE_VSYNC: 588 case MODE_V_ILLEGAL: 589 free(mode); 590 return VidModeErrorBase + XF86VidModeBadVTimings; 591 default: 592 free(mode); 593 return VidModeErrorBase + XF86VidModeModeUnsuitable; 594 } 595 596 /* Check that the driver is happy with the mode */ 597 if (pVidMode->CheckModeForDriver(pScreen, mode) != MODE_OK) { 598 free(mode); 599 return VidModeErrorBase + XF86VidModeModeUnsuitable; 600 } 601 602 pVidMode->SetCrtcForMode(pScreen, mode); 603 604 pVidMode->AddModeline(pScreen, mode); 605 606 DebugF("AddModeLine - Succeeded\n"); 607 608 return Success; 609 } 610 611 static int 612 ProcVidModeDeleteModeLine(ClientPtr client) 613 { 614 REQUEST(xXF86VidModeDeleteModeLineReq); 615 xXF86OldVidModeDeleteModeLineReq *oldstuff = 616 (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer; 617 xXF86VidModeDeleteModeLineReq newstuff; 618 ScreenPtr pScreen; 619 VidModePtr pVidMode; 620 DisplayModePtr mode; 621 int len, dotClock; 622 int ver; 623 624 DEBUG_P("XF86VidModeDeleteModeline"); 625 626 ver = ClientMajorVersion(client); 627 628 if (ver < 2) { 629 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq); 630 len = 631 client->req_len - 632 bytes_to_int32(sizeof(xXF86OldVidModeDeleteModeLineReq)); 633 } 634 else { 635 REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq); 636 len = 637 client->req_len - 638 bytes_to_int32(sizeof(xXF86VidModeDeleteModeLineReq)); 639 } 640 641 if (ver < 2) { 642 /* convert from old format */ 643 stuff = &newstuff; 644 stuff->length = oldstuff->length; 645 stuff->screen = oldstuff->screen; 646 stuff->dotclock = oldstuff->dotclock; 647 stuff->hdisplay = oldstuff->hdisplay; 648 stuff->hsyncstart = oldstuff->hsyncstart; 649 stuff->hsyncend = oldstuff->hsyncend; 650 stuff->htotal = oldstuff->htotal; 651 stuff->hskew = 0; 652 stuff->vdisplay = oldstuff->vdisplay; 653 stuff->vsyncstart = oldstuff->vsyncstart; 654 stuff->vsyncend = oldstuff->vsyncend; 655 stuff->vtotal = oldstuff->vtotal; 656 stuff->flags = oldstuff->flags; 657 stuff->privsize = oldstuff->privsize; 658 } 659 DebugF("DeleteModeLine - scrn: %d clock: %ld\n", 660 (int) stuff->screen, (unsigned long) stuff->dotclock); 661 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", 662 stuff->hdisplay, stuff->hsyncstart, 663 stuff->hsyncend, stuff->htotal); 664 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", 665 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal, 666 (unsigned long) stuff->flags); 667 668 if (len != stuff->privsize) { 669 DebugF("req_len = %ld, sizeof(Req) = %d, privsize = %ld, " 670 "len = %d, length = %d\n", 671 (unsigned long) client->req_len, 672 (int) sizeof(xXF86VidModeDeleteModeLineReq) >> 2, 673 (unsigned long) stuff->privsize, len, stuff->length); 674 return BadLength; 675 } 676 677 if (stuff->screen >= screenInfo.numScreens) 678 return BadValue; 679 pScreen = screenInfo.screens[stuff->screen]; 680 681 pVidMode = VidModeGetPtr(pScreen); 682 if (pVidMode == NULL) 683 return BadImplementation; 684 685 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock)) 686 return BadValue; 687 688 DebugF("Checking against clock: %d (%d)\n", 689 VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock); 690 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", 691 VidModeGetModeValue(mode, VIDMODE_H_DISPLAY), 692 VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART), 693 VidModeGetModeValue(mode, VIDMODE_H_SYNCEND), 694 VidModeGetModeValue(mode, VIDMODE_H_TOTAL)); 695 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n", 696 VidModeGetModeValue(mode, VIDMODE_V_DISPLAY), 697 VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART), 698 VidModeGetModeValue(mode, VIDMODE_V_SYNCEND), 699 VidModeGetModeValue(mode, VIDMODE_V_TOTAL), 700 VidModeGetModeValue(mode, VIDMODE_FLAGS)); 701 702 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) && 703 MODEMATCH(mode, stuff)) 704 return BadValue; 705 706 if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock)) 707 return BadValue; 708 709 do { 710 DebugF("Checking against clock: %d (%d)\n", 711 VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock); 712 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", 713 VidModeGetModeValue(mode, VIDMODE_H_DISPLAY), 714 VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART), 715 VidModeGetModeValue(mode, VIDMODE_H_SYNCEND), 716 VidModeGetModeValue(mode, VIDMODE_H_TOTAL)); 717 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n", 718 VidModeGetModeValue(mode, VIDMODE_V_DISPLAY), 719 VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART), 720 VidModeGetModeValue(mode, VIDMODE_V_SYNCEND), 721 VidModeGetModeValue(mode, VIDMODE_V_TOTAL), 722 VidModeGetModeValue(mode, VIDMODE_FLAGS)); 723 724 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) && 725 MODEMATCH(mode, stuff)) { 726 pVidMode->DeleteModeline(pScreen, mode); 727 DebugF("DeleteModeLine - Succeeded\n"); 728 return Success; 729 } 730 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock)); 731 732 return BadValue; 733 } 734 735 static int 736 ProcVidModeModModeLine(ClientPtr client) 737 { 738 REQUEST(xXF86VidModeModModeLineReq); 739 xXF86OldVidModeModModeLineReq *oldstuff = 740 (xXF86OldVidModeModModeLineReq *) client->requestBuffer; 741 xXF86VidModeModModeLineReq newstuff; 742 ScreenPtr pScreen; 743 VidModePtr pVidMode; 744 DisplayModePtr mode, modetmp; 745 int len, dotClock; 746 int ver; 747 748 DEBUG_P("XF86VidModeModModeline"); 749 750 ver = ClientMajorVersion(client); 751 752 if (ver < 2) { 753 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq); 754 len = 755 client->req_len - 756 bytes_to_int32(sizeof(xXF86OldVidModeModModeLineReq)); 757 } 758 else { 759 REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq); 760 len = 761 client->req_len - 762 bytes_to_int32(sizeof(xXF86VidModeModModeLineReq)); 763 } 764 765 if (ver < 2) { 766 /* convert from old format */ 767 stuff = &newstuff; 768 stuff->length = oldstuff->length; 769 stuff->screen = oldstuff->screen; 770 stuff->hdisplay = oldstuff->hdisplay; 771 stuff->hsyncstart = oldstuff->hsyncstart; 772 stuff->hsyncend = oldstuff->hsyncend; 773 stuff->htotal = oldstuff->htotal; 774 stuff->hskew = 0; 775 stuff->vdisplay = oldstuff->vdisplay; 776 stuff->vsyncstart = oldstuff->vsyncstart; 777 stuff->vsyncend = oldstuff->vsyncend; 778 stuff->vtotal = oldstuff->vtotal; 779 stuff->flags = oldstuff->flags; 780 stuff->privsize = oldstuff->privsize; 781 } 782 DebugF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n", 783 (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart, 784 stuff->hsyncend, stuff->htotal); 785 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", 786 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, 787 stuff->vtotal, (unsigned long) stuff->flags); 788 789 if (len != stuff->privsize) 790 return BadLength; 791 792 if (stuff->hsyncstart < stuff->hdisplay || 793 stuff->hsyncend < stuff->hsyncstart || 794 stuff->htotal < stuff->hsyncend || 795 stuff->vsyncstart < stuff->vdisplay || 796 stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend) 797 return BadValue; 798 799 if (stuff->screen >= screenInfo.numScreens) 800 return BadValue; 801 pScreen = screenInfo.screens[stuff->screen]; 802 803 pVidMode = VidModeGetPtr(pScreen); 804 if (pVidMode == NULL) 805 return BadImplementation; 806 807 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock)) 808 return BadValue; 809 810 modetmp = VidModeCreateMode(); 811 VidModeCopyMode(mode, modetmp); 812 813 VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay); 814 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart); 815 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend); 816 VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal); 817 VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew); 818 VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay); 819 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart); 820 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend); 821 VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal); 822 VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags); 823 824 if (stuff->privsize) 825 DebugF("ModModeLine - Privates in request have been ignored\n"); 826 827 /* Check that the mode is consistent with the monitor specs */ 828 switch (pVidMode->CheckModeForMonitor(pScreen, modetmp)) { 829 case MODE_OK: 830 break; 831 case MODE_HSYNC: 832 case MODE_H_ILLEGAL: 833 free(modetmp); 834 return VidModeErrorBase + XF86VidModeBadHTimings; 835 case MODE_VSYNC: 836 case MODE_V_ILLEGAL: 837 free(modetmp); 838 return VidModeErrorBase + XF86VidModeBadVTimings; 839 default: 840 free(modetmp); 841 return VidModeErrorBase + XF86VidModeModeUnsuitable; 842 } 843 844 /* Check that the driver is happy with the mode */ 845 if (pVidMode->CheckModeForDriver(pScreen, modetmp) != MODE_OK) { 846 free(modetmp); 847 return VidModeErrorBase + XF86VidModeModeUnsuitable; 848 } 849 free(modetmp); 850 851 VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay); 852 VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart); 853 VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend); 854 VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal); 855 VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew); 856 VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay); 857 VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart); 858 VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend); 859 VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal); 860 VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags); 861 862 pVidMode->SetCrtcForMode(pScreen, mode); 863 pVidMode->SwitchMode(pScreen, mode); 864 865 DebugF("ModModeLine - Succeeded\n"); 866 return Success; 867 } 868 869 static int 870 ProcVidModeValidateModeLine(ClientPtr client) 871 { 872 REQUEST(xXF86VidModeValidateModeLineReq); 873 xXF86OldVidModeValidateModeLineReq *oldstuff = 874 (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer; 875 xXF86VidModeValidateModeLineReq newstuff; 876 xXF86VidModeValidateModeLineReply rep; 877 ScreenPtr pScreen; 878 VidModePtr pVidMode; 879 DisplayModePtr mode, modetmp = NULL; 880 int len, status, dotClock; 881 int ver; 882 883 DEBUG_P("XF86VidModeValidateModeline"); 884 885 ver = ClientMajorVersion(client); 886 887 if (ver < 2) { 888 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq); 889 len = client->req_len - 890 bytes_to_int32(sizeof(xXF86OldVidModeValidateModeLineReq)); 891 } 892 else { 893 REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq); 894 len = 895 client->req_len - 896 bytes_to_int32(sizeof(xXF86VidModeValidateModeLineReq)); 897 } 898 899 if (ver < 2) { 900 /* convert from old format */ 901 stuff = &newstuff; 902 stuff->length = oldstuff->length; 903 stuff->screen = oldstuff->screen; 904 stuff->dotclock = oldstuff->dotclock; 905 stuff->hdisplay = oldstuff->hdisplay; 906 stuff->hsyncstart = oldstuff->hsyncstart; 907 stuff->hsyncend = oldstuff->hsyncend; 908 stuff->htotal = oldstuff->htotal; 909 stuff->hskew = 0; 910 stuff->vdisplay = oldstuff->vdisplay; 911 stuff->vsyncstart = oldstuff->vsyncstart; 912 stuff->vsyncend = oldstuff->vsyncend; 913 stuff->vtotal = oldstuff->vtotal; 914 stuff->flags = oldstuff->flags; 915 stuff->privsize = oldstuff->privsize; 916 } 917 918 DebugF("ValidateModeLine - scrn: %d clock: %ld\n", 919 (int) stuff->screen, (unsigned long) stuff->dotclock); 920 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", 921 stuff->hdisplay, stuff->hsyncstart, 922 stuff->hsyncend, stuff->htotal); 923 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", 924 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal, 925 (unsigned long) stuff->flags); 926 927 if (len != stuff->privsize) 928 return BadLength; 929 930 if (stuff->screen >= screenInfo.numScreens) 931 return BadValue; 932 pScreen = screenInfo.screens[stuff->screen]; 933 934 status = MODE_OK; 935 936 if (stuff->hsyncstart < stuff->hdisplay || 937 stuff->hsyncend < stuff->hsyncstart || 938 stuff->htotal < stuff->hsyncend || 939 stuff->vsyncstart < stuff->vdisplay || 940 stuff->vsyncend < stuff->vsyncstart || 941 stuff->vtotal < stuff->vsyncend) { 942 status = MODE_BAD; 943 goto status_reply; 944 } 945 946 pVidMode = VidModeGetPtr(pScreen); 947 if (pVidMode == NULL) 948 return BadImplementation; 949 950 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock)) 951 return BadValue; 952 953 modetmp = VidModeCreateMode(); 954 VidModeCopyMode(mode, modetmp); 955 956 VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay); 957 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart); 958 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend); 959 VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal); 960 VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew); 961 VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay); 962 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart); 963 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend); 964 VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal); 965 VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags); 966 if (stuff->privsize) 967 DebugF("ValidateModeLine - Privates in request have been ignored\n"); 968 969 /* Check that the mode is consistent with the monitor specs */ 970 if ((status = 971 pVidMode->CheckModeForMonitor(pScreen, modetmp)) != MODE_OK) 972 goto status_reply; 973 974 /* Check that the driver is happy with the mode */ 975 status = pVidMode->CheckModeForDriver(pScreen, modetmp); 976 977 status_reply: 978 free(modetmp); 979 980 rep = (xXF86VidModeValidateModeLineReply) { 981 .type = X_Reply, 982 .sequenceNumber = client->sequence, 983 .length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply) 984 - SIZEOF(xGenericReply)), 985 .status = status 986 }; 987 if (client->swapped) { 988 swaps(&rep.sequenceNumber); 989 swapl(&rep.length); 990 swapl(&rep.status); 991 } 992 WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), &rep); 993 DebugF("ValidateModeLine - Succeeded (status = %d)\n", status); 994 995 return Success; 996 } 997 998 static int 999 ProcVidModeSwitchMode(ClientPtr client) 1000 { 1001 REQUEST(xXF86VidModeSwitchModeReq); 1002 ScreenPtr pScreen; 1003 VidModePtr pVidMode; 1004 1005 DEBUG_P("XF86VidModeSwitchMode"); 1006 1007 REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq); 1008 1009 if (stuff->screen >= screenInfo.numScreens) 1010 return BadValue; 1011 pScreen = screenInfo.screens[stuff->screen]; 1012 1013 pVidMode = VidModeGetPtr(pScreen); 1014 if (pVidMode == NULL) 1015 return BadImplementation; 1016 1017 pVidMode->ZoomViewport(pScreen, (short) stuff->zoom); 1018 1019 return Success; 1020 } 1021 1022 static int 1023 ProcVidModeSwitchToMode(ClientPtr client) 1024 { 1025 REQUEST(xXF86VidModeSwitchToModeReq); 1026 xXF86OldVidModeSwitchToModeReq *oldstuff = 1027 (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer; 1028 xXF86VidModeSwitchToModeReq newstuff; 1029 ScreenPtr pScreen; 1030 VidModePtr pVidMode; 1031 DisplayModePtr mode; 1032 int len, dotClock; 1033 int ver; 1034 1035 DEBUG_P("XF86VidModeSwitchToMode"); 1036 1037 ver = ClientMajorVersion(client); 1038 1039 if (ver < 2) { 1040 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeSwitchToModeReq); 1041 len = 1042 client->req_len - 1043 bytes_to_int32(sizeof(xXF86OldVidModeSwitchToModeReq)); 1044 } 1045 else { 1046 REQUEST_AT_LEAST_SIZE(xXF86VidModeSwitchToModeReq); 1047 len = 1048 client->req_len - 1049 bytes_to_int32(sizeof(xXF86VidModeSwitchToModeReq)); 1050 } 1051 1052 if (ver < 2) { 1053 /* convert from old format */ 1054 stuff = &newstuff; 1055 stuff->length = oldstuff->length; 1056 stuff->screen = oldstuff->screen; 1057 stuff->dotclock = oldstuff->dotclock; 1058 stuff->hdisplay = oldstuff->hdisplay; 1059 stuff->hsyncstart = oldstuff->hsyncstart; 1060 stuff->hsyncend = oldstuff->hsyncend; 1061 stuff->htotal = oldstuff->htotal; 1062 stuff->hskew = 0; 1063 stuff->vdisplay = oldstuff->vdisplay; 1064 stuff->vsyncstart = oldstuff->vsyncstart; 1065 stuff->vsyncend = oldstuff->vsyncend; 1066 stuff->vtotal = oldstuff->vtotal; 1067 stuff->flags = oldstuff->flags; 1068 stuff->privsize = oldstuff->privsize; 1069 } 1070 1071 DebugF("SwitchToMode - scrn: %d clock: %ld\n", 1072 (int) stuff->screen, (unsigned long) stuff->dotclock); 1073 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", 1074 stuff->hdisplay, stuff->hsyncstart, 1075 stuff->hsyncend, stuff->htotal); 1076 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n", 1077 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal, 1078 (unsigned long) stuff->flags); 1079 1080 if (len != stuff->privsize) 1081 return BadLength; 1082 1083 if (stuff->screen >= screenInfo.numScreens) 1084 return BadValue; 1085 pScreen = screenInfo.screens[stuff->screen]; 1086 1087 pVidMode = VidModeGetPtr(pScreen); 1088 if (pVidMode == NULL) 1089 return BadImplementation; 1090 1091 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock)) 1092 return BadValue; 1093 1094 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) 1095 && MODEMATCH(mode, stuff)) 1096 return Success; 1097 1098 if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock)) 1099 return BadValue; 1100 1101 do { 1102 DebugF("Checking against clock: %d (%d)\n", 1103 VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock); 1104 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n", 1105 VidModeGetModeValue(mode, VIDMODE_H_DISPLAY), 1106 VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART), 1107 VidModeGetModeValue(mode, VIDMODE_H_SYNCEND), 1108 VidModeGetModeValue(mode, VIDMODE_H_TOTAL)); 1109 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n", 1110 VidModeGetModeValue(mode, VIDMODE_V_DISPLAY), 1111 VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART), 1112 VidModeGetModeValue(mode, VIDMODE_V_SYNCEND), 1113 VidModeGetModeValue(mode, VIDMODE_V_TOTAL), 1114 VidModeGetModeValue(mode, VIDMODE_FLAGS)); 1115 1116 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) && 1117 MODEMATCH(mode, stuff)) { 1118 1119 if (!pVidMode->SwitchMode(pScreen, mode)) 1120 return BadValue; 1121 1122 DebugF("SwitchToMode - Succeeded\n"); 1123 return Success; 1124 } 1125 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock)); 1126 1127 return BadValue; 1128 } 1129 1130 static int 1131 ProcVidModeLockModeSwitch(ClientPtr client) 1132 { 1133 REQUEST(xXF86VidModeLockModeSwitchReq); 1134 ScreenPtr pScreen; 1135 VidModePtr pVidMode; 1136 1137 REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq); 1138 1139 DEBUG_P("XF86VidModeLockModeSwitch"); 1140 1141 if (stuff->screen >= screenInfo.numScreens) 1142 return BadValue; 1143 pScreen = screenInfo.screens[stuff->screen]; 1144 1145 pVidMode = VidModeGetPtr(pScreen); 1146 if (pVidMode == NULL) 1147 return BadImplementation; 1148 1149 if (!pVidMode->LockZoom(pScreen, (short) stuff->lock)) 1150 return VidModeErrorBase + XF86VidModeZoomLocked; 1151 1152 return Success; 1153 } 1154 1155 static int 1156 ProcVidModeGetMonitor(ClientPtr client) 1157 { 1158 REQUEST(xXF86VidModeGetMonitorReq); 1159 xXF86VidModeGetMonitorReply rep = { 1160 .type = X_Reply, 1161 .sequenceNumber = client->sequence 1162 }; 1163 CARD32 *hsyncdata, *vsyncdata; 1164 ScreenPtr pScreen; 1165 VidModePtr pVidMode; 1166 int i, nHsync, nVrefresh; 1167 1168 DEBUG_P("XF86VidModeGetMonitor"); 1169 1170 REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq); 1171 1172 if (stuff->screen >= screenInfo.numScreens) 1173 return BadValue; 1174 pScreen = screenInfo.screens[stuff->screen]; 1175 1176 pVidMode = VidModeGetPtr(pScreen); 1177 if (pVidMode == NULL) 1178 return BadImplementation; 1179 1180 nHsync = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i; 1181 nVrefresh = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i; 1182 1183 if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr) 1184 rep.vendorLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen, 1185 VIDMODE_MON_VENDOR, 1186 0)).ptr); 1187 else 1188 rep.vendorLength = 0; 1189 if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr) 1190 rep.modelLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen, 1191 VIDMODE_MON_MODEL, 1192 0)).ptr); 1193 else 1194 rep.modelLength = 0; 1195 rep.length = 1196 bytes_to_int32(SIZEOF(xXF86VidModeGetMonitorReply) - 1197 SIZEOF(xGenericReply) + (nHsync + 1198 nVrefresh) * sizeof(CARD32) + 1199 pad_to_int32(rep.vendorLength) + 1200 pad_to_int32(rep.modelLength)); 1201 rep.nhsync = nHsync; 1202 rep.nvsync = nVrefresh; 1203 hsyncdata = xallocarray(nHsync, sizeof(CARD32)); 1204 if (!hsyncdata) { 1205 return BadAlloc; 1206 } 1207 vsyncdata = xallocarray(nVrefresh, sizeof(CARD32)); 1208 1209 if (!vsyncdata) { 1210 free(hsyncdata); 1211 return BadAlloc; 1212 } 1213 1214 for (i = 0; i < nHsync; i++) { 1215 hsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen, 1216 VIDMODE_MON_HSYNC_LO, 1217 i)).f | 1218 (unsigned 1219 short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI, 1220 i)).f << 16; 1221 } 1222 for (i = 0; i < nVrefresh; i++) { 1223 vsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen, 1224 VIDMODE_MON_VREFRESH_LO, 1225 i)).f | 1226 (unsigned 1227 short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI, 1228 i)).f << 16; 1229 } 1230 1231 if (client->swapped) { 1232 swaps(&rep.sequenceNumber); 1233 swapl(&rep.length); 1234 } 1235 WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), &rep); 1236 client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; 1237 WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), hsyncdata); 1238 WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata); 1239 if (rep.vendorLength) 1240 WriteToClient(client, rep.vendorLength, 1241 (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr); 1242 if (rep.modelLength) 1243 WriteToClient(client, rep.modelLength, 1244 (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr); 1245 1246 free(hsyncdata); 1247 free(vsyncdata); 1248 1249 return Success; 1250 } 1251 1252 static int 1253 ProcVidModeGetViewPort(ClientPtr client) 1254 { 1255 REQUEST(xXF86VidModeGetViewPortReq); 1256 xXF86VidModeGetViewPortReply rep; 1257 ScreenPtr pScreen; 1258 VidModePtr pVidMode; 1259 int x, y; 1260 1261 DEBUG_P("XF86VidModeGetViewPort"); 1262 1263 REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq); 1264 1265 if (stuff->screen >= screenInfo.numScreens) 1266 return BadValue; 1267 pScreen = screenInfo.screens[stuff->screen]; 1268 1269 pVidMode = VidModeGetPtr(pScreen); 1270 if (pVidMode == NULL) 1271 return BadImplementation; 1272 1273 pVidMode->GetViewPort(pScreen, &x, &y); 1274 1275 rep = (xXF86VidModeGetViewPortReply) { 1276 .type = X_Reply, 1277 .sequenceNumber = client->sequence, 1278 .length = 0, 1279 .x = x, 1280 .y = y 1281 }; 1282 1283 if (client->swapped) { 1284 swaps(&rep.sequenceNumber); 1285 swapl(&rep.length); 1286 swapl(&rep.x); 1287 swapl(&rep.y); 1288 } 1289 WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), &rep); 1290 return Success; 1291 } 1292 1293 static int 1294 ProcVidModeSetViewPort(ClientPtr client) 1295 { 1296 REQUEST(xXF86VidModeSetViewPortReq); 1297 ScreenPtr pScreen; 1298 VidModePtr pVidMode; 1299 1300 DEBUG_P("XF86VidModeSetViewPort"); 1301 1302 REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq); 1303 1304 if (stuff->screen >= screenInfo.numScreens) 1305 return BadValue; 1306 pScreen = screenInfo.screens[stuff->screen]; 1307 1308 pVidMode = VidModeGetPtr(pScreen); 1309 if (pVidMode == NULL) 1310 return BadImplementation; 1311 1312 if (!pVidMode->SetViewPort(pScreen, stuff->x, stuff->y)) 1313 return BadValue; 1314 1315 return Success; 1316 } 1317 1318 static int 1319 ProcVidModeGetDotClocks(ClientPtr client) 1320 { 1321 REQUEST(xXF86VidModeGetDotClocksReq); 1322 xXF86VidModeGetDotClocksReply rep; 1323 ScreenPtr pScreen; 1324 VidModePtr pVidMode; 1325 int n; 1326 int numClocks; 1327 CARD32 dotclock; 1328 int *Clocks = NULL; 1329 Bool ClockProg; 1330 1331 DEBUG_P("XF86VidModeGetDotClocks"); 1332 1333 REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq); 1334 1335 if (stuff->screen >= screenInfo.numScreens) 1336 return BadValue; 1337 pScreen = screenInfo.screens[stuff->screen]; 1338 1339 pVidMode = VidModeGetPtr(pScreen); 1340 if (pVidMode == NULL) 1341 return BadImplementation; 1342 1343 numClocks = pVidMode->GetNumOfClocks(pScreen, &ClockProg); 1344 1345 rep = (xXF86VidModeGetDotClocksReply) { 1346 .type = X_Reply, 1347 .sequenceNumber = client->sequence, 1348 .length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply) 1349 - SIZEOF(xGenericReply) + numClocks), 1350 .clocks = numClocks, 1351 .maxclocks = MAXCLOCKS, 1352 .flags = 0 1353 }; 1354 1355 if (!ClockProg) { 1356 Clocks = calloc(numClocks, sizeof(int)); 1357 if (!Clocks) 1358 return BadValue; 1359 if (!pVidMode->GetClocks(pScreen, Clocks)) { 1360 free(Clocks); 1361 return BadValue; 1362 } 1363 } 1364 if (ClockProg) { 1365 rep.flags |= CLKFLAG_PROGRAMABLE; 1366 } 1367 if (client->swapped) { 1368 swaps(&rep.sequenceNumber); 1369 swapl(&rep.length); 1370 swapl(&rep.clocks); 1371 swapl(&rep.maxclocks); 1372 swapl(&rep.flags); 1373 } 1374 WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), &rep); 1375 if (!ClockProg) { 1376 for (n = 0; n < numClocks; n++) { 1377 dotclock = Clocks[n]; 1378 if (client->swapped) { 1379 WriteSwappedDataToClient(client, 4, (char *) &dotclock); 1380 } 1381 else { 1382 WriteToClient(client, 4, &dotclock); 1383 } 1384 } 1385 } 1386 1387 free(Clocks); 1388 return Success; 1389 } 1390 1391 static int 1392 ProcVidModeSetGamma(ClientPtr client) 1393 { 1394 REQUEST(xXF86VidModeSetGammaReq); 1395 ScreenPtr pScreen; 1396 VidModePtr pVidMode; 1397 1398 DEBUG_P("XF86VidModeSetGamma"); 1399 1400 REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq); 1401 1402 if (stuff->screen >= screenInfo.numScreens) 1403 return BadValue; 1404 pScreen = screenInfo.screens[stuff->screen]; 1405 1406 pVidMode = VidModeGetPtr(pScreen); 1407 if (pVidMode == NULL) 1408 return BadImplementation; 1409 1410 if (!pVidMode->SetGamma(pScreen, ((float) stuff->red) / 10000., 1411 ((float) stuff->green) / 10000., 1412 ((float) stuff->blue) / 10000.)) 1413 return BadValue; 1414 1415 return Success; 1416 } 1417 1418 static int 1419 ProcVidModeGetGamma(ClientPtr client) 1420 { 1421 REQUEST(xXF86VidModeGetGammaReq); 1422 xXF86VidModeGetGammaReply rep; 1423 ScreenPtr pScreen; 1424 VidModePtr pVidMode; 1425 float red, green, blue; 1426 1427 DEBUG_P("XF86VidModeGetGamma"); 1428 1429 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq); 1430 1431 if (stuff->screen >= screenInfo.numScreens) 1432 return BadValue; 1433 pScreen = screenInfo.screens[stuff->screen]; 1434 1435 pVidMode = VidModeGetPtr(pScreen); 1436 if (pVidMode == NULL) 1437 return BadImplementation; 1438 1439 if (!pVidMode->GetGamma(pScreen, &red, &green, &blue)) 1440 return BadValue; 1441 rep = (xXF86VidModeGetGammaReply) { 1442 .type = X_Reply, 1443 .sequenceNumber = client->sequence, 1444 .length = 0, 1445 .red = (CARD32) (red * 10000.), 1446 .green = (CARD32) (green * 10000.), 1447 .blue = (CARD32) (blue * 10000.) 1448 }; 1449 if (client->swapped) { 1450 swaps(&rep.sequenceNumber); 1451 swapl(&rep.length); 1452 swapl(&rep.red); 1453 swapl(&rep.green); 1454 swapl(&rep.blue); 1455 } 1456 WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), &rep); 1457 1458 return Success; 1459 } 1460 1461 static int 1462 ProcVidModeSetGammaRamp(ClientPtr client) 1463 { 1464 CARD16 *r, *g, *b; 1465 int length; 1466 ScreenPtr pScreen; 1467 VidModePtr pVidMode; 1468 1469 REQUEST(xXF86VidModeSetGammaRampReq); 1470 REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq); 1471 1472 if (stuff->screen >= screenInfo.numScreens) 1473 return BadValue; 1474 pScreen = screenInfo.screens[stuff->screen]; 1475 1476 pVidMode = VidModeGetPtr(pScreen); 1477 if (pVidMode == NULL) 1478 return BadImplementation; 1479 1480 if (stuff->size != pVidMode->GetGammaRampSize(pScreen)) 1481 return BadValue; 1482 1483 length = (stuff->size + 1) & ~1; 1484 1485 REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6); 1486 1487 r = (CARD16 *) &stuff[1]; 1488 g = r + length; 1489 b = g + length; 1490 1491 if (!pVidMode->SetGammaRamp(pScreen, stuff->size, r, g, b)) 1492 return BadValue; 1493 1494 return Success; 1495 } 1496 1497 static int 1498 ProcVidModeGetGammaRamp(ClientPtr client) 1499 { 1500 CARD16 *ramp = NULL; 1501 int length; 1502 size_t ramplen = 0; 1503 xXF86VidModeGetGammaRampReply rep; 1504 ScreenPtr pScreen; 1505 VidModePtr pVidMode; 1506 1507 REQUEST(xXF86VidModeGetGammaRampReq); 1508 1509 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq); 1510 1511 if (stuff->screen >= screenInfo.numScreens) 1512 return BadValue; 1513 pScreen = screenInfo.screens[stuff->screen]; 1514 1515 pVidMode = VidModeGetPtr(pScreen); 1516 if (pVidMode == NULL) 1517 return BadImplementation; 1518 1519 if (stuff->size != pVidMode->GetGammaRampSize(pScreen)) 1520 return BadValue; 1521 1522 length = (stuff->size + 1) & ~1; 1523 1524 if (stuff->size) { 1525 if (!(ramp = xallocarray(length, 3 * sizeof(CARD16)))) 1526 return BadAlloc; 1527 ramplen = length * 3 * sizeof(CARD16); 1528 1529 if (!pVidMode->GetGammaRamp(pScreen, stuff->size, 1530 ramp, ramp + length, ramp + (length * 2))) { 1531 free(ramp); 1532 return BadValue; 1533 } 1534 } 1535 rep = (xXF86VidModeGetGammaRampReply) { 1536 .type = X_Reply, 1537 .sequenceNumber = client->sequence, 1538 .length = (length >> 1) * 3, 1539 .size = stuff->size 1540 }; 1541 if (client->swapped) { 1542 swaps(&rep.sequenceNumber); 1543 swapl(&rep.length); 1544 swaps(&rep.size); 1545 SwapShorts((short *) ramp, length * 3); 1546 } 1547 WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), &rep); 1548 1549 if (stuff->size) { 1550 WriteToClient(client, ramplen, ramp); 1551 free(ramp); 1552 } 1553 1554 return Success; 1555 } 1556 1557 1558 static int 1559 ProcVidModeGetGammaRampSize(ClientPtr client) 1560 { 1561 xXF86VidModeGetGammaRampSizeReply rep; 1562 ScreenPtr pScreen; 1563 VidModePtr pVidMode; 1564 1565 REQUEST(xXF86VidModeGetGammaRampSizeReq); 1566 1567 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq); 1568 1569 if (stuff->screen >= screenInfo.numScreens) 1570 return BadValue; 1571 pScreen = screenInfo.screens[stuff->screen]; 1572 1573 pVidMode = VidModeGetPtr(pScreen); 1574 if (pVidMode == NULL) 1575 return BadImplementation; 1576 1577 rep = (xXF86VidModeGetGammaRampSizeReply) { 1578 .type = X_Reply, 1579 .sequenceNumber = client->sequence, 1580 .length = 0, 1581 .size = pVidMode->GetGammaRampSize(pScreen) 1582 }; 1583 if (client->swapped) { 1584 swaps(&rep.sequenceNumber); 1585 swapl(&rep.length); 1586 swaps(&rep.size); 1587 } 1588 WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), &rep); 1589 1590 return Success; 1591 } 1592 1593 static int 1594 ProcVidModeGetPermissions(ClientPtr client) 1595 { 1596 xXF86VidModeGetPermissionsReply rep = { 1597 .type = X_Reply, 1598 .sequenceNumber = client->sequence, 1599 .length = 0, 1600 .permissions = XF86VM_READ_PERMISSION 1601 }; 1602 1603 REQUEST(xXF86VidModeGetPermissionsReq); 1604 1605 REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq); 1606 1607 if (stuff->screen >= screenInfo.numScreens) 1608 return BadValue; 1609 1610 if (VidModeAllowNonLocal || client->local) { 1611 rep.permissions |= XF86VM_WRITE_PERMISSION; 1612 } 1613 if (client->swapped) { 1614 swaps(&rep.sequenceNumber); 1615 swapl(&rep.length); 1616 swapl(&rep.permissions); 1617 } 1618 WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply), &rep); 1619 1620 return Success; 1621 } 1622 1623 static int 1624 ProcVidModeSetClientVersion(ClientPtr client) 1625 { 1626 REQUEST(xXF86VidModeSetClientVersionReq); 1627 1628 VidModePrivPtr pPriv; 1629 1630 DEBUG_P("XF86VidModeSetClientVersion"); 1631 1632 REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq); 1633 1634 if ((pPriv = VM_GETPRIV(client)) == NULL) { 1635 pPriv = malloc(sizeof(VidModePrivRec)); 1636 if (!pPriv) 1637 return BadAlloc; 1638 VM_SETPRIV(client, pPriv); 1639 } 1640 pPriv->major = stuff->major; 1641 1642 pPriv->minor = stuff->minor; 1643 1644 return Success; 1645 } 1646 1647 static int 1648 ProcVidModeDispatch(ClientPtr client) 1649 { 1650 REQUEST(xReq); 1651 switch (stuff->data) { 1652 case X_XF86VidModeQueryVersion: 1653 return ProcVidModeQueryVersion(client); 1654 case X_XF86VidModeGetModeLine: 1655 return ProcVidModeGetModeLine(client); 1656 case X_XF86VidModeGetMonitor: 1657 return ProcVidModeGetMonitor(client); 1658 case X_XF86VidModeGetAllModeLines: 1659 return ProcVidModeGetAllModeLines(client); 1660 case X_XF86VidModeValidateModeLine: 1661 return ProcVidModeValidateModeLine(client); 1662 case X_XF86VidModeGetViewPort: 1663 return ProcVidModeGetViewPort(client); 1664 case X_XF86VidModeGetDotClocks: 1665 return ProcVidModeGetDotClocks(client); 1666 case X_XF86VidModeSetClientVersion: 1667 return ProcVidModeSetClientVersion(client); 1668 case X_XF86VidModeGetGamma: 1669 return ProcVidModeGetGamma(client); 1670 case X_XF86VidModeGetGammaRamp: 1671 return ProcVidModeGetGammaRamp(client); 1672 case X_XF86VidModeGetGammaRampSize: 1673 return ProcVidModeGetGammaRampSize(client); 1674 case X_XF86VidModeGetPermissions: 1675 return ProcVidModeGetPermissions(client); 1676 default: 1677 if (VidModeAllowNonLocal || client->local) { 1678 switch (stuff->data) { 1679 case X_XF86VidModeAddModeLine: 1680 return ProcVidModeAddModeLine(client); 1681 case X_XF86VidModeDeleteModeLine: 1682 return ProcVidModeDeleteModeLine(client); 1683 case X_XF86VidModeModModeLine: 1684 return ProcVidModeModModeLine(client); 1685 case X_XF86VidModeSwitchMode: 1686 return ProcVidModeSwitchMode(client); 1687 case X_XF86VidModeSwitchToMode: 1688 return ProcVidModeSwitchToMode(client); 1689 case X_XF86VidModeLockModeSwitch: 1690 return ProcVidModeLockModeSwitch(client); 1691 case X_XF86VidModeSetViewPort: 1692 return ProcVidModeSetViewPort(client); 1693 case X_XF86VidModeSetGamma: 1694 return ProcVidModeSetGamma(client); 1695 case X_XF86VidModeSetGammaRamp: 1696 return ProcVidModeSetGammaRamp(client); 1697 default: 1698 return BadRequest; 1699 } 1700 } 1701 else 1702 return VidModeErrorBase + XF86VidModeClientNotLocal; 1703 } 1704 } 1705 1706 static int _X_COLD 1707 SProcVidModeQueryVersion(ClientPtr client) 1708 { 1709 REQUEST(xXF86VidModeQueryVersionReq); 1710 swaps(&stuff->length); 1711 return ProcVidModeQueryVersion(client); 1712 } 1713 1714 static int _X_COLD 1715 SProcVidModeGetModeLine(ClientPtr client) 1716 { 1717 REQUEST(xXF86VidModeGetModeLineReq); 1718 swaps(&stuff->length); 1719 REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq); 1720 swaps(&stuff->screen); 1721 return ProcVidModeGetModeLine(client); 1722 } 1723 1724 static int _X_COLD 1725 SProcVidModeGetAllModeLines(ClientPtr client) 1726 { 1727 REQUEST(xXF86VidModeGetAllModeLinesReq); 1728 swaps(&stuff->length); 1729 REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq); 1730 swaps(&stuff->screen); 1731 return ProcVidModeGetAllModeLines(client); 1732 } 1733 1734 static int _X_COLD 1735 SProcVidModeAddModeLine(ClientPtr client) 1736 { 1737 xXF86OldVidModeAddModeLineReq *oldstuff = 1738 (xXF86OldVidModeAddModeLineReq *) client->requestBuffer; 1739 int ver; 1740 1741 REQUEST(xXF86VidModeAddModeLineReq); 1742 ver = ClientMajorVersion(client); 1743 if (ver < 2) { 1744 swaps(&oldstuff->length); 1745 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq); 1746 swapl(&oldstuff->screen); 1747 swaps(&oldstuff->hdisplay); 1748 swaps(&oldstuff->hsyncstart); 1749 swaps(&oldstuff->hsyncend); 1750 swaps(&oldstuff->htotal); 1751 swaps(&oldstuff->vdisplay); 1752 swaps(&oldstuff->vsyncstart); 1753 swaps(&oldstuff->vsyncend); 1754 swaps(&oldstuff->vtotal); 1755 swapl(&oldstuff->flags); 1756 swapl(&oldstuff->privsize); 1757 SwapRestL(oldstuff); 1758 } 1759 else { 1760 swaps(&stuff->length); 1761 REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq); 1762 swapl(&stuff->screen); 1763 swaps(&stuff->hdisplay); 1764 swaps(&stuff->hsyncstart); 1765 swaps(&stuff->hsyncend); 1766 swaps(&stuff->htotal); 1767 swaps(&stuff->hskew); 1768 swaps(&stuff->vdisplay); 1769 swaps(&stuff->vsyncstart); 1770 swaps(&stuff->vsyncend); 1771 swaps(&stuff->vtotal); 1772 swapl(&stuff->flags); 1773 swapl(&stuff->privsize); 1774 SwapRestL(stuff); 1775 } 1776 return ProcVidModeAddModeLine(client); 1777 } 1778 1779 static int _X_COLD 1780 SProcVidModeDeleteModeLine(ClientPtr client) 1781 { 1782 xXF86OldVidModeDeleteModeLineReq *oldstuff = 1783 (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer; 1784 int ver; 1785 1786 REQUEST(xXF86VidModeDeleteModeLineReq); 1787 ver = ClientMajorVersion(client); 1788 if (ver < 2) { 1789 swaps(&oldstuff->length); 1790 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq); 1791 swapl(&oldstuff->screen); 1792 swaps(&oldstuff->hdisplay); 1793 swaps(&oldstuff->hsyncstart); 1794 swaps(&oldstuff->hsyncend); 1795 swaps(&oldstuff->htotal); 1796 swaps(&oldstuff->vdisplay); 1797 swaps(&oldstuff->vsyncstart); 1798 swaps(&oldstuff->vsyncend); 1799 swaps(&oldstuff->vtotal); 1800 swapl(&oldstuff->flags); 1801 swapl(&oldstuff->privsize); 1802 SwapRestL(oldstuff); 1803 } 1804 else { 1805 swaps(&stuff->length); 1806 REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq); 1807 swapl(&stuff->screen); 1808 swaps(&stuff->hdisplay); 1809 swaps(&stuff->hsyncstart); 1810 swaps(&stuff->hsyncend); 1811 swaps(&stuff->htotal); 1812 swaps(&stuff->hskew); 1813 swaps(&stuff->vdisplay); 1814 swaps(&stuff->vsyncstart); 1815 swaps(&stuff->vsyncend); 1816 swaps(&stuff->vtotal); 1817 swapl(&stuff->flags); 1818 swapl(&stuff->privsize); 1819 SwapRestL(stuff); 1820 } 1821 return ProcVidModeDeleteModeLine(client); 1822 } 1823 1824 static int _X_COLD 1825 SProcVidModeModModeLine(ClientPtr client) 1826 { 1827 xXF86OldVidModeModModeLineReq *oldstuff = 1828 (xXF86OldVidModeModModeLineReq *) client->requestBuffer; 1829 int ver; 1830 1831 REQUEST(xXF86VidModeModModeLineReq); 1832 ver = ClientMajorVersion(client); 1833 if (ver < 2) { 1834 swaps(&oldstuff->length); 1835 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq); 1836 swapl(&oldstuff->screen); 1837 swaps(&oldstuff->hdisplay); 1838 swaps(&oldstuff->hsyncstart); 1839 swaps(&oldstuff->hsyncend); 1840 swaps(&oldstuff->htotal); 1841 swaps(&oldstuff->vdisplay); 1842 swaps(&oldstuff->vsyncstart); 1843 swaps(&oldstuff->vsyncend); 1844 swaps(&oldstuff->vtotal); 1845 swapl(&oldstuff->flags); 1846 swapl(&oldstuff->privsize); 1847 SwapRestL(oldstuff); 1848 } 1849 else { 1850 swaps(&stuff->length); 1851 REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq); 1852 swapl(&stuff->screen); 1853 swaps(&stuff->hdisplay); 1854 swaps(&stuff->hsyncstart); 1855 swaps(&stuff->hsyncend); 1856 swaps(&stuff->htotal); 1857 swaps(&stuff->hskew); 1858 swaps(&stuff->vdisplay); 1859 swaps(&stuff->vsyncstart); 1860 swaps(&stuff->vsyncend); 1861 swaps(&stuff->vtotal); 1862 swapl(&stuff->flags); 1863 swapl(&stuff->privsize); 1864 SwapRestL(stuff); 1865 } 1866 return ProcVidModeModModeLine(client); 1867 } 1868 1869 static int _X_COLD 1870 SProcVidModeValidateModeLine(ClientPtr client) 1871 { 1872 xXF86OldVidModeValidateModeLineReq *oldstuff = 1873 (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer; 1874 int ver; 1875 1876 REQUEST(xXF86VidModeValidateModeLineReq); 1877 ver = ClientMajorVersion(client); 1878 if (ver < 2) { 1879 swaps(&oldstuff->length); 1880 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq); 1881 swapl(&oldstuff->screen); 1882 swaps(&oldstuff->hdisplay); 1883 swaps(&oldstuff->hsyncstart); 1884 swaps(&oldstuff->hsyncend); 1885 swaps(&oldstuff->htotal); 1886 swaps(&oldstuff->vdisplay); 1887 swaps(&oldstuff->vsyncstart); 1888 swaps(&oldstuff->vsyncend); 1889 swaps(&oldstuff->vtotal); 1890 swapl(&oldstuff->flags); 1891 swapl(&oldstuff->privsize); 1892 SwapRestL(oldstuff); 1893 } 1894 else { 1895 swaps(&stuff->length); 1896 REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq); 1897 swapl(&stuff->screen); 1898 swaps(&stuff->hdisplay); 1899 swaps(&stuff->hsyncstart); 1900 swaps(&stuff->hsyncend); 1901 swaps(&stuff->htotal); 1902 swaps(&stuff->hskew); 1903 swaps(&stuff->vdisplay); 1904 swaps(&stuff->vsyncstart); 1905 swaps(&stuff->vsyncend); 1906 swaps(&stuff->vtotal); 1907 swapl(&stuff->flags); 1908 swapl(&stuff->privsize); 1909 SwapRestL(stuff); 1910 } 1911 return ProcVidModeValidateModeLine(client); 1912 } 1913 1914 static int _X_COLD 1915 SProcVidModeSwitchMode(ClientPtr client) 1916 { 1917 REQUEST(xXF86VidModeSwitchModeReq); 1918 swaps(&stuff->length); 1919 REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq); 1920 swaps(&stuff->screen); 1921 swaps(&stuff->zoom); 1922 return ProcVidModeSwitchMode(client); 1923 } 1924 1925 static int _X_COLD 1926 SProcVidModeSwitchToMode(ClientPtr client) 1927 { 1928 REQUEST(xXF86VidModeSwitchToModeReq); 1929 swaps(&stuff->length); 1930 REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq); 1931 swapl(&stuff->screen); 1932 return ProcVidModeSwitchToMode(client); 1933 } 1934 1935 static int _X_COLD 1936 SProcVidModeLockModeSwitch(ClientPtr client) 1937 { 1938 REQUEST(xXF86VidModeLockModeSwitchReq); 1939 swaps(&stuff->length); 1940 REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq); 1941 swaps(&stuff->screen); 1942 swaps(&stuff->lock); 1943 return ProcVidModeLockModeSwitch(client); 1944 } 1945 1946 static int _X_COLD 1947 SProcVidModeGetMonitor(ClientPtr client) 1948 { 1949 REQUEST(xXF86VidModeGetMonitorReq); 1950 swaps(&stuff->length); 1951 REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq); 1952 swaps(&stuff->screen); 1953 return ProcVidModeGetMonitor(client); 1954 } 1955 1956 static int _X_COLD 1957 SProcVidModeGetViewPort(ClientPtr client) 1958 { 1959 REQUEST(xXF86VidModeGetViewPortReq); 1960 swaps(&stuff->length); 1961 REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq); 1962 swaps(&stuff->screen); 1963 return ProcVidModeGetViewPort(client); 1964 } 1965 1966 static int _X_COLD 1967 SProcVidModeSetViewPort(ClientPtr client) 1968 { 1969 REQUEST(xXF86VidModeSetViewPortReq); 1970 swaps(&stuff->length); 1971 REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq); 1972 swaps(&stuff->screen); 1973 swapl(&stuff->x); 1974 swapl(&stuff->y); 1975 return ProcVidModeSetViewPort(client); 1976 } 1977 1978 static int _X_COLD 1979 SProcVidModeGetDotClocks(ClientPtr client) 1980 { 1981 REQUEST(xXF86VidModeGetDotClocksReq); 1982 swaps(&stuff->length); 1983 REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq); 1984 swaps(&stuff->screen); 1985 return ProcVidModeGetDotClocks(client); 1986 } 1987 1988 static int _X_COLD 1989 SProcVidModeSetClientVersion(ClientPtr client) 1990 { 1991 REQUEST(xXF86VidModeSetClientVersionReq); 1992 swaps(&stuff->length); 1993 REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq); 1994 swaps(&stuff->major); 1995 swaps(&stuff->minor); 1996 return ProcVidModeSetClientVersion(client); 1997 } 1998 1999 static int _X_COLD 2000 SProcVidModeSetGamma(ClientPtr client) 2001 { 2002 REQUEST(xXF86VidModeSetGammaReq); 2003 swaps(&stuff->length); 2004 REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq); 2005 swaps(&stuff->screen); 2006 swapl(&stuff->red); 2007 swapl(&stuff->green); 2008 swapl(&stuff->blue); 2009 return ProcVidModeSetGamma(client); 2010 } 2011 2012 static int _X_COLD 2013 SProcVidModeGetGamma(ClientPtr client) 2014 { 2015 REQUEST(xXF86VidModeGetGammaReq); 2016 swaps(&stuff->length); 2017 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq); 2018 swaps(&stuff->screen); 2019 return ProcVidModeGetGamma(client); 2020 } 2021 2022 static int _X_COLD 2023 SProcVidModeSetGammaRamp(ClientPtr client) 2024 { 2025 int length; 2026 2027 REQUEST(xXF86VidModeSetGammaRampReq); 2028 swaps(&stuff->length); 2029 REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq); 2030 swaps(&stuff->size); 2031 swaps(&stuff->screen); 2032 length = ((stuff->size + 1) & ~1) * 6; 2033 REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length); 2034 SwapRestS(stuff); 2035 return ProcVidModeSetGammaRamp(client); 2036 } 2037 2038 static int _X_COLD 2039 SProcVidModeGetGammaRamp(ClientPtr client) 2040 { 2041 REQUEST(xXF86VidModeGetGammaRampReq); 2042 swaps(&stuff->length); 2043 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq); 2044 swaps(&stuff->size); 2045 swaps(&stuff->screen); 2046 return ProcVidModeGetGammaRamp(client); 2047 } 2048 2049 static int _X_COLD 2050 SProcVidModeGetGammaRampSize(ClientPtr client) 2051 { 2052 REQUEST(xXF86VidModeGetGammaRampSizeReq); 2053 swaps(&stuff->length); 2054 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq); 2055 swaps(&stuff->screen); 2056 return ProcVidModeGetGammaRampSize(client); 2057 } 2058 2059 static int _X_COLD 2060 SProcVidModeGetPermissions(ClientPtr client) 2061 { 2062 REQUEST(xXF86VidModeGetPermissionsReq); 2063 swaps(&stuff->length); 2064 REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq); 2065 swaps(&stuff->screen); 2066 return ProcVidModeGetPermissions(client); 2067 } 2068 2069 static int _X_COLD 2070 SProcVidModeDispatch(ClientPtr client) 2071 { 2072 REQUEST(xReq); 2073 switch (stuff->data) { 2074 case X_XF86VidModeQueryVersion: 2075 return SProcVidModeQueryVersion(client); 2076 case X_XF86VidModeGetModeLine: 2077 return SProcVidModeGetModeLine(client); 2078 case X_XF86VidModeGetMonitor: 2079 return SProcVidModeGetMonitor(client); 2080 case X_XF86VidModeGetAllModeLines: 2081 return SProcVidModeGetAllModeLines(client); 2082 case X_XF86VidModeGetViewPort: 2083 return SProcVidModeGetViewPort(client); 2084 case X_XF86VidModeValidateModeLine: 2085 return SProcVidModeValidateModeLine(client); 2086 case X_XF86VidModeGetDotClocks: 2087 return SProcVidModeGetDotClocks(client); 2088 case X_XF86VidModeSetClientVersion: 2089 return SProcVidModeSetClientVersion(client); 2090 case X_XF86VidModeGetGamma: 2091 return SProcVidModeGetGamma(client); 2092 case X_XF86VidModeGetGammaRamp: 2093 return SProcVidModeGetGammaRamp(client); 2094 case X_XF86VidModeGetGammaRampSize: 2095 return SProcVidModeGetGammaRampSize(client); 2096 case X_XF86VidModeGetPermissions: 2097 return SProcVidModeGetPermissions(client); 2098 default: 2099 if (VidModeAllowNonLocal || client->local) { 2100 switch (stuff->data) { 2101 case X_XF86VidModeAddModeLine: 2102 return SProcVidModeAddModeLine(client); 2103 case X_XF86VidModeDeleteModeLine: 2104 return SProcVidModeDeleteModeLine(client); 2105 case X_XF86VidModeModModeLine: 2106 return SProcVidModeModModeLine(client); 2107 case X_XF86VidModeSwitchMode: 2108 return SProcVidModeSwitchMode(client); 2109 case X_XF86VidModeSwitchToMode: 2110 return SProcVidModeSwitchToMode(client); 2111 case X_XF86VidModeLockModeSwitch: 2112 return SProcVidModeLockModeSwitch(client); 2113 case X_XF86VidModeSetViewPort: 2114 return SProcVidModeSetViewPort(client); 2115 case X_XF86VidModeSetGamma: 2116 return SProcVidModeSetGamma(client); 2117 case X_XF86VidModeSetGammaRamp: 2118 return SProcVidModeSetGammaRamp(client); 2119 default: 2120 return BadRequest; 2121 } 2122 } 2123 else 2124 return VidModeErrorBase + XF86VidModeClientNotLocal; 2125 } 2126 } 2127 2128 void 2129 VidModeAddExtension(Bool allow_non_local) 2130 { 2131 ExtensionEntry *extEntry; 2132 2133 DEBUG_P("VidModeAddExtension"); 2134 2135 if (!dixRegisterPrivateKey(VidModeClientPrivateKey, PRIVATE_CLIENT, 0)) 2136 return; 2137 2138 if ((extEntry = AddExtension(XF86VIDMODENAME, 2139 XF86VidModeNumberEvents, 2140 XF86VidModeNumberErrors, 2141 ProcVidModeDispatch, 2142 SProcVidModeDispatch, 2143 NULL, StandardMinorOpcode))) { 2144 VidModeErrorBase = extEntry->errorBase; 2145 VidModeAllowNonLocal = allow_non_local; 2146 } 2147 } 2148 2149 VidModePtr VidModeGetPtr(ScreenPtr pScreen) 2150 { 2151 return (VidModePtr) (dixLookupPrivate(&pScreen->devPrivates, VidModePrivateKey)); 2152 } 2153 2154 VidModePtr VidModeInit(ScreenPtr pScreen) 2155 { 2156 if (!dixRegisterPrivateKey(VidModePrivateKey, PRIVATE_SCREEN, sizeof(VidModeRec))) 2157 return NULL; 2158 2159 return VidModeGetPtr(pScreen); 2160 } 2161 2162 #endif /* XF86VIDMODE */