Home | History | Annotate | Download | only in libXNVCtrl 
      1 /*
      2  * Copyright (c) 2008 NVIDIA, Corporation
      3  *
      4  * Permission is hereby granted, free of charge, to any person obtaining a copy
      5  * of this software and associated documentation files (the "Software"), to deal
      6  * in the Software without restriction, including without limitation the rights
      7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      8  * copies of the Software, and to permit persons to whom the Software is
      9  * furnished to do so, subject to the following conditions:
     10  *
     11  * The above copyright notice and this permission notice (including the next
     12  * paragraph) shall be included in all copies or substantial portions of the
     13  * Software.
     14  *
     15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
     18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     21  * SOFTWARE.
     22  */
     23 
     24 /*
     25  * Make sure that XTHREADS is defined, so that the
     26  * LockDisplay/UnlockDisplay macros are expanded properly and the
     27  * libXNVCtrl library properly protects the Display connection.
     28  */
     29 
     30 #if !defined(XTHREADS)
     31 #define XTHREADS
     32 #endif /* XTHREADS */
     33 
     34 #define NEED_EVENTS
     35 #define NEED_REPLIES
     36 #include <stdint.h>
     37 #include <stdlib.h>
     38 #include <X11/Xlibint.h>
     39 #include <X11/Xutil.h>
     40 #include <X11/extensions/Xext.h>
     41 #include <X11/extensions/extutil.h>
     42 #include "NVCtrlLib.h"
     43 #include "nv_control.h"
     44 
     45 #define NVCTRL_EXT_EXISTS              1
     46 #define NVCTRL_EXT_NEED_TARGET_SWAP    2
     47 #define NVCTRL_EXT_64_BIT_ATTRIBUTES   4
     48 #define NVCTRL_EXT_NEED_CHECK          (1 << (sizeof(XPointer) - 1))
     49 
     50 static XExtensionInfo _nvctrl_ext_info_data;
     51 static XExtensionInfo *nvctrl_ext_info = &_nvctrl_ext_info_data;
     52 static /* const */ char *nvctrl_extension_name = NV_CONTROL_NAME;
     53 
     54 #define XNVCTRLCheckExtension(dpy,i,val) \
     55   XextCheckExtension (dpy, i, nvctrl_extension_name, val)
     56 #define XNVCTRLSimpleCheckExtension(dpy,i) \
     57   XextSimpleCheckExtension (dpy, i, nvctrl_extension_name)
     58 
     59 static int close_display();
     60 static uintptr_t version_flags(Display *dpy, XExtDisplayInfo *info);
     61 static Bool wire_to_event();
     62 static /* const */ XExtensionHooks nvctrl_extension_hooks = {
     63     NULL,                               /* create_gc */
     64     NULL,                               /* copy_gc */
     65     NULL,                               /* flush_gc */
     66     NULL,                               /* free_gc */
     67     NULL,                               /* create_font */
     68     NULL,                               /* free_font */
     69     close_display,                      /* close_display */
     70     wire_to_event,                      /* wire_to_event */
     71     NULL,                               /* event_to_wire */
     72     NULL,                               /* error */
     73     NULL,                               /* error_string */
     74 };
     75 
     76 static XEXT_GENERATE_FIND_DISPLAY (find_display, nvctrl_ext_info,
     77                                    nvctrl_extension_name,
     78                                    &nvctrl_extension_hooks,
     79                                    NV_CONTROL_EVENTS,
     80                                    (XPointer)NVCTRL_EXT_NEED_CHECK)
     81 
     82 static XEXT_GENERATE_CLOSE_DISPLAY (close_display, nvctrl_ext_info)
     83 
     84 /*
     85  * NV-CONTROL versions 1.8 and 1.9 pack the target_type and target_id
     86  * fields in reversed order.  In order to talk to one of these servers,
     87  * we need to swap these fields.
     88  */
     89 
     90 static void XNVCTRLCheckTargetData(Display *dpy, XExtDisplayInfo *info,
     91                                    int *target_type, int *target_id)
     92 {
     93     uintptr_t flags = version_flags(dpy, info);
     94 
     95     /* We need to swap the target_type and target_id */
     96     if (flags & NVCTRL_EXT_NEED_TARGET_SWAP) {
     97         int tmp;
     98         tmp = *target_type;
     99         *target_type = *target_id;
    100         *target_id = tmp;
    101     }
    102 }
    103 
    104 
    105 Bool XNVCTRLQueryExtension (
    106     Display *dpy,
    107     int *event_basep,
    108     int *error_basep
    109 ){
    110     XExtDisplayInfo *info = find_display (dpy);
    111 
    112     if (XextHasExtension(info)) {
    113         if (event_basep) *event_basep = info->codes->first_event;
    114         if (error_basep) *error_basep = info->codes->first_error;
    115         return True;
    116     } else {
    117         return False;
    118     }
    119 }
    120 
    121 /*
    122  * Retrieve any cached flags that depend on the version of the NV-CONTROL
    123  * extension.
    124  */
    125 
    126 static uintptr_t version_flags(Display *dpy, XExtDisplayInfo *info)
    127 {
    128     uintptr_t data = (uintptr_t)info->data;
    129 
    130     /* If necessary, determine the NV-CONTROL version */
    131     if (data & NVCTRL_EXT_NEED_CHECK) {
    132         int major, minor;
    133         data = 0;
    134         if (XNVCTRLQueryVersion(dpy, &major, &minor)) {
    135             data |= NVCTRL_EXT_EXISTS;
    136             if (major == 1 && (minor == 8 || minor == 9)) {
    137                 data |= NVCTRL_EXT_NEED_TARGET_SWAP;
    138             }
    139             if ((major > 1) || ((major == 1) && (minor > 20))) {
    140                 data |= NVCTRL_EXT_64_BIT_ATTRIBUTES;
    141             }
    142         }
    143 
    144         info->data = (XPointer)data;
    145     }
    146 
    147     return data;
    148 }
    149 
    150 Bool XNVCTRLQueryVersion (
    151     Display *dpy,
    152     int *major,
    153     int *minor
    154 ){
    155     XExtDisplayInfo *info = find_display (dpy);
    156     xnvCtrlQueryExtensionReply rep;
    157     xnvCtrlQueryExtensionReq   *req;
    158 
    159     if(!XextHasExtension(info))
    160         return False;
    161 
    162     XNVCTRLCheckExtension (dpy, info, False);
    163 
    164     LockDisplay (dpy);
    165     GetReq (nvCtrlQueryExtension, req);
    166     req->reqType = info->codes->major_opcode;
    167     req->nvReqType = X_nvCtrlQueryExtension;
    168     if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
    169         UnlockDisplay (dpy);
    170         SyncHandle ();
    171         return False;
    172     }
    173     if (major) *major = rep.major;
    174     if (minor) *minor = rep.minor;
    175     UnlockDisplay (dpy);
    176     SyncHandle ();
    177     return True;
    178 }
    179 
    180 
    181 Bool XNVCTRLIsNvScreen (
    182     Display *dpy,
    183     int screen
    184 ){
    185     XExtDisplayInfo *info = find_display (dpy);
    186     xnvCtrlIsNvReply rep;
    187     xnvCtrlIsNvReq   *req;
    188     Bool isnv;
    189 
    190     if(!XextHasExtension(info))
    191         return False;
    192 
    193     XNVCTRLCheckExtension (dpy, info, False);
    194 
    195     LockDisplay (dpy);
    196     GetReq (nvCtrlIsNv, req);
    197     req->reqType = info->codes->major_opcode;
    198     req->nvReqType = X_nvCtrlIsNv;
    199     req->screen = screen;
    200     if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
    201         UnlockDisplay (dpy);
    202         SyncHandle ();
    203         return False;
    204     }
    205     isnv = rep.isnv;
    206     UnlockDisplay (dpy);
    207     SyncHandle ();
    208     return isnv;
    209 }
    210 
    211 
    212 Bool XNVCTRLQueryTargetCount (
    213     Display *dpy,
    214     int target_type,
    215     int *value
    216 ){
    217     XExtDisplayInfo *info = find_display (dpy);
    218     xnvCtrlQueryTargetCountReply  rep;
    219     xnvCtrlQueryTargetCountReq   *req;
    220 
    221     if(!XextHasExtension(info))
    222         return False;
    223 
    224     XNVCTRLCheckExtension (dpy, info, False);
    225 
    226     LockDisplay (dpy);
    227     GetReq (nvCtrlQueryTargetCount, req);
    228     req->reqType = info->codes->major_opcode;
    229     req->nvReqType = X_nvCtrlQueryTargetCount;
    230     req->target_type = target_type;
    231     if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
    232         UnlockDisplay (dpy);
    233         SyncHandle ();
    234         return False;
    235     }
    236     if (value) *value = rep.count;
    237     UnlockDisplay (dpy);
    238     SyncHandle ();
    239     return True;
    240 }
    241 
    242 
    243 void XNVCTRLSetTargetAttribute (
    244     Display *dpy,
    245     int target_type,
    246     int target_id,
    247     unsigned int display_mask,
    248     unsigned int attribute,
    249     int value
    250 ){
    251     XExtDisplayInfo *info = find_display (dpy);
    252     xnvCtrlSetAttributeReq *req;
    253 
    254     XNVCTRLSimpleCheckExtension (dpy, info);
    255     XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
    256 
    257     LockDisplay (dpy);
    258     GetReq (nvCtrlSetAttribute, req);
    259     req->reqType = info->codes->major_opcode;
    260     req->nvReqType = X_nvCtrlSetAttribute;
    261     req->target_type = target_type;
    262     req->target_id = target_id;
    263     req->display_mask = display_mask;
    264     req->attribute = attribute;
    265     req->value = value;
    266     UnlockDisplay (dpy);
    267     SyncHandle ();
    268 }
    269 
    270 void XNVCTRLSetAttribute (
    271     Display *dpy,
    272     int screen,
    273     unsigned int display_mask,
    274     unsigned int attribute,
    275     int value
    276 ){
    277     XNVCTRLSetTargetAttribute (dpy, NV_CTRL_TARGET_TYPE_X_SCREEN, screen,
    278                                display_mask, attribute, value);
    279 }
    280 
    281 
    282 Bool XNVCTRLSetTargetAttributeAndGetStatus (
    283     Display *dpy,
    284     int target_type,
    285     int target_id,
    286     unsigned int display_mask,
    287     unsigned int attribute,
    288     int value
    289 ){
    290     XExtDisplayInfo *info = find_display (dpy);
    291     xnvCtrlSetAttributeAndGetStatusReq *req;
    292     xnvCtrlSetAttributeAndGetStatusReply rep;
    293     Bool success;
    294 
    295     if(!XextHasExtension(info))
    296         return False;
    297 
    298     XNVCTRLCheckExtension (dpy, info, False);
    299 
    300     LockDisplay (dpy);
    301     GetReq (nvCtrlSetAttributeAndGetStatus, req);
    302     req->reqType = info->codes->major_opcode;
    303     req->nvReqType = X_nvCtrlSetAttributeAndGetStatus;
    304     req->target_type = target_type;
    305     req->target_id = target_id;
    306     req->display_mask = display_mask;
    307     req->attribute = attribute;
    308     req->value = value;
    309     if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
    310         UnlockDisplay (dpy);
    311         SyncHandle ();
    312         return False;
    313     }
    314     UnlockDisplay (dpy);
    315     SyncHandle ();
    316 
    317     success = rep.flags;
    318     return success;
    319 }
    320 
    321 Bool XNVCTRLSetAttributeAndGetStatus (
    322     Display *dpy,
    323     int screen,
    324     unsigned int display_mask,
    325     unsigned int attribute,
    326     int value
    327 ){
    328     return XNVCTRLSetTargetAttributeAndGetStatus(dpy,
    329                                                  NV_CTRL_TARGET_TYPE_X_SCREEN,
    330                                                  screen, display_mask,
    331                                                  attribute, value);
    332 }
    333 
    334 
    335 Bool XNVCTRLQueryTargetAttribute (
    336     Display *dpy,
    337     int target_type,
    338     int target_id,
    339     unsigned int display_mask,
    340     unsigned int attribute,
    341     int *value
    342 ){
    343     XExtDisplayInfo *info = find_display (dpy);
    344     xnvCtrlQueryAttributeReply rep;
    345     xnvCtrlQueryAttributeReq   *req;
    346     Bool exists;
    347 
    348     if(!XextHasExtension(info))
    349         return False;
    350 
    351     XNVCTRLCheckExtension (dpy, info, False);
    352     XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
    353 
    354     LockDisplay (dpy);
    355     GetReq (nvCtrlQueryAttribute, req);
    356     req->reqType = info->codes->major_opcode;
    357     req->nvReqType = X_nvCtrlQueryAttribute;
    358     req->target_type = target_type;
    359     req->target_id = target_id;
    360     req->display_mask = display_mask;
    361     req->attribute = attribute;
    362     if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
    363         UnlockDisplay (dpy);
    364         SyncHandle ();
    365         return False;
    366     }
    367     exists = rep.flags;
    368     if (exists && value) *value = rep.value;
    369     UnlockDisplay (dpy);
    370     SyncHandle ();
    371     return exists;
    372 }
    373 
    374 Bool XNVCTRLQueryAttribute (
    375     Display *dpy,
    376     int screen,
    377     unsigned int display_mask,
    378     unsigned int attribute,
    379     int *value
    380 ){
    381     return XNVCTRLQueryTargetAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
    382                                        screen, display_mask, attribute, value);
    383 }
    384 
    385 
    386 Bool XNVCTRLQueryTargetAttribute64 (
    387     Display *dpy,
    388     int target_type,
    389     int target_id,
    390     unsigned int display_mask,
    391     unsigned int attribute,
    392     int64_t *value
    393 ){
    394     XExtDisplayInfo *info = find_display(dpy);
    395     xnvCtrlQueryAttribute64Reply rep;
    396     xnvCtrlQueryAttributeReq *req;
    397     Bool exists;
    398 
    399     if (!XextHasExtension(info))
    400         return False;
    401 
    402     XNVCTRLCheckExtension(dpy, info, False);
    403     XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
    404 
    405     LockDisplay(dpy);
    406     GetReq(nvCtrlQueryAttribute, req);
    407     req->reqType = info->codes->major_opcode;
    408     req->nvReqType = X_nvCtrlQueryAttribute64;
    409     req->target_type = target_type;
    410     req->target_id = target_id;
    411     req->display_mask = display_mask;
    412     req->attribute = attribute;
    413     if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) {
    414         UnlockDisplay(dpy);
    415         SyncHandle();
    416         return False;
    417     }
    418     exists = rep.flags;
    419     if (exists && value) *value = rep.value_64;
    420     UnlockDisplay(dpy);
    421     SyncHandle();
    422     return exists;
    423 }
    424 
    425 
    426 Bool XNVCTRLQueryTargetStringAttribute (
    427     Display *dpy,
    428     int target_type,
    429     int target_id,
    430     unsigned int display_mask,
    431     unsigned int attribute,
    432     char **ptr
    433 ){
    434     XExtDisplayInfo *info = find_display (dpy);
    435     xnvCtrlQueryStringAttributeReply rep;
    436     xnvCtrlQueryStringAttributeReq   *req;
    437     Bool exists;
    438     int length, numbytes, slop;
    439 
    440     if (!ptr) return False;
    441 
    442     if(!XextHasExtension(info))
    443         return False;
    444 
    445     XNVCTRLCheckExtension (dpy, info, False);
    446     XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
    447 
    448     LockDisplay (dpy);
    449     GetReq (nvCtrlQueryStringAttribute, req);
    450     req->reqType = info->codes->major_opcode;
    451     req->nvReqType = X_nvCtrlQueryStringAttribute;
    452     req->target_type = target_type;
    453     req->target_id = target_id;
    454     req->display_mask = display_mask;
    455     req->attribute = attribute;
    456     if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
    457         UnlockDisplay (dpy);
    458         SyncHandle ();
    459         return False;
    460     }
    461     length = rep.length;
    462     numbytes = rep.n;
    463     slop = numbytes & 3;
    464     exists = rep.flags;
    465     if (exists) {
    466         *ptr = (char *) Xmalloc(numbytes);
    467     }
    468     if (!exists || !*ptr) {
    469         _XEatData(dpy, length);
    470         UnlockDisplay (dpy);
    471         SyncHandle ();
    472         return False;
    473     } else {
    474         _XRead(dpy, (char *) *ptr, numbytes);
    475         if (slop) _XEatData(dpy, 4-slop);
    476     }
    477     UnlockDisplay (dpy);
    478     SyncHandle ();
    479     return exists;
    480 }
    481 
    482 Bool XNVCTRLQueryStringAttribute (
    483     Display *dpy,
    484     int screen,
    485     unsigned int display_mask,
    486     unsigned int attribute,
    487     char **ptr
    488 ){
    489     return XNVCTRLQueryTargetStringAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
    490                                              screen, display_mask,
    491                                              attribute, ptr);
    492 }
    493 
    494 
    495 Bool XNVCTRLSetTargetStringAttribute (
    496     Display *dpy,
    497     int target_type,
    498     int target_id,
    499     unsigned int display_mask,
    500     unsigned int attribute,
    501     char *ptr
    502 ){
    503     XExtDisplayInfo *info = find_display (dpy);
    504     xnvCtrlSetStringAttributeReq *req;
    505     xnvCtrlSetStringAttributeReply rep;
    506     int size;
    507     Bool success;
    508 
    509     if(!XextHasExtension(info))
    510         return False;
    511 
    512     XNVCTRLCheckExtension (dpy, info, False);
    513 
    514     size = strlen(ptr)+1;
    515 
    516     LockDisplay (dpy);
    517     GetReq (nvCtrlSetStringAttribute, req);
    518     req->reqType = info->codes->major_opcode;
    519     req->nvReqType = X_nvCtrlSetStringAttribute;
    520     req->target_type = target_type;
    521     req->target_id = target_id;
    522     req->display_mask = display_mask;
    523     req->attribute = attribute;
    524     req->length += ((size + 3) & ~3) >> 2;
    525     req->num_bytes = size;
    526     Data(dpy, ptr, size);
    527 
    528     if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
    529         UnlockDisplay (dpy);
    530         SyncHandle ();
    531         return False;
    532     }
    533     UnlockDisplay (dpy);
    534     SyncHandle ();
    535 
    536     success = rep.flags;
    537     return success;
    538 }
    539 
    540 Bool XNVCTRLSetStringAttribute (
    541     Display *dpy,
    542     int screen,
    543     unsigned int display_mask,
    544     unsigned int attribute,
    545     char *ptr
    546 ){
    547     return XNVCTRLSetTargetStringAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
    548                                            screen, display_mask,
    549                                            attribute, ptr);
    550 }
    551 
    552 
    553 static Bool XNVCTRLQueryValidTargetAttributeValues32 (
    554     Display *dpy,
    555     XExtDisplayInfo *info,
    556     int target_type,
    557     int target_id,
    558     unsigned int display_mask,
    559     unsigned int attribute,
    560     NVCTRLAttributeValidValuesRec *values
    561 ){
    562     xnvCtrlQueryValidAttributeValuesReply rep;
    563     xnvCtrlQueryValidAttributeValuesReq   *req;
    564     Bool exists;
    565 
    566     LockDisplay (dpy);
    567     GetReq (nvCtrlQueryValidAttributeValues, req);
    568     req->reqType = info->codes->major_opcode;
    569     req->nvReqType = X_nvCtrlQueryValidAttributeValues;
    570     req->target_type = target_type;
    571     req->target_id = target_id;
    572     req->display_mask = display_mask;
    573     req->attribute = attribute;
    574     if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
    575         UnlockDisplay (dpy);
    576         SyncHandle ();
    577         return False;
    578     }
    579     exists = rep.flags;
    580     if (exists) {
    581         values->type = rep.attr_type;
    582         if (rep.attr_type == ATTRIBUTE_TYPE_RANGE) {
    583             values->u.range.min = rep.min;
    584             values->u.range.max = rep.max;
    585         }
    586         if (rep.attr_type == ATTRIBUTE_TYPE_INT_BITS) {
    587             values->u.bits.ints = rep.bits;
    588         }
    589         values->permissions = rep.perms;
    590     }
    591     UnlockDisplay (dpy);
    592     SyncHandle ();
    593     return exists;
    594 }
    595 
    596 
    597 Bool XNVCTRLQueryValidTargetStringAttributeValues (
    598     Display *dpy,
    599     int target_type,
    600     int target_id,
    601     unsigned int display_mask,
    602     unsigned int attribute,
    603     NVCTRLAttributeValidValuesRec *values
    604 ){
    605     XExtDisplayInfo *info = find_display(dpy);
    606     Bool exists;
    607     xnvCtrlQueryValidAttributeValuesReply rep;
    608     xnvCtrlQueryValidAttributeValuesReq   *req;
    609 
    610     if (!values) return False;
    611 
    612     if (!XextHasExtension(info))
    613         return False;
    614 
    615     XNVCTRLCheckExtension(dpy, info, False);
    616 
    617     LockDisplay(dpy);
    618     GetReq (nvCtrlQueryValidAttributeValues, req);
    619     req->reqType = info->codes->major_opcode;
    620     req->nvReqType = X_nvCtrlQueryValidStringAttributeValues;
    621     req->target_type = target_type;
    622     req->target_id = target_id;
    623     req->display_mask = display_mask;
    624     req->attribute = attribute;
    625     if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) {
    626         UnlockDisplay(dpy);
    627         SyncHandle();
    628         return False;
    629     }
    630     exists = rep.flags;
    631     if (exists) {
    632         values->type = rep.attr_type;
    633         values->permissions = rep.perms;
    634     }
    635     UnlockDisplay(dpy);
    636     SyncHandle();
    637     return exists;
    638 }
    639 
    640 
    641 static Bool XNVCTRLQueryValidTargetAttributeValues64 (
    642     Display *dpy,
    643     XExtDisplayInfo *info,
    644     int target_type,
    645     int target_id,
    646     unsigned int display_mask,
    647     unsigned int attribute,
    648     NVCTRLAttributeValidValuesRec *values
    649 ){
    650     xnvCtrlQueryValidAttributeValues64Reply rep;
    651     xnvCtrlQueryValidAttributeValuesReq *req;
    652     Bool exists;
    653 
    654     LockDisplay(dpy);
    655     GetReq(nvCtrlQueryValidAttributeValues, req);
    656     req->reqType = info->codes->major_opcode;
    657     req->nvReqType = X_nvCtrlQueryValidAttributeValues64;
    658     req->target_type = target_type;
    659     req->target_id = target_id;
    660     req->display_mask = display_mask;
    661     req->attribute = attribute;
    662     if (!_XReply(dpy, (xReply *)&rep,
    663                  sz_xnvCtrlQueryValidAttributeValues64Reply_extra,
    664                  xTrue)) {
    665         UnlockDisplay(dpy);
    666         SyncHandle();
    667         return False;
    668     }
    669     exists = rep.flags;
    670     if (exists) {
    671         values->type = rep.attr_type;
    672         if (rep.attr_type == ATTRIBUTE_TYPE_RANGE) {
    673             values->u.range.min = rep.min_64;
    674             values->u.range.max = rep.max_64;
    675         }
    676         if (rep.attr_type == ATTRIBUTE_TYPE_INT_BITS) {
    677             values->u.bits.ints = rep.bits_64;
    678         }
    679         values->permissions = rep.perms;
    680     }
    681     UnlockDisplay(dpy);
    682     SyncHandle();
    683     return exists;
    684 }
    685 
    686 Bool XNVCTRLQueryValidTargetAttributeValues (
    687     Display *dpy,
    688     int target_type,
    689     int target_id,
    690     unsigned int display_mask,
    691     unsigned int attribute,
    692     NVCTRLAttributeValidValuesRec *values
    693 ){
    694     XExtDisplayInfo *info = find_display(dpy);
    695     Bool exists;
    696     uintptr_t flags;
    697 
    698     if (!values) return False;
    699 
    700     if (!XextHasExtension(info))
    701         return False;
    702 
    703     XNVCTRLCheckExtension(dpy, info, False);
    704     XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
    705 
    706     flags = version_flags(dpy,info);
    707 
    708     if (!(flags & NVCTRL_EXT_EXISTS))
    709         return False;
    710 
    711     if (flags & NVCTRL_EXT_64_BIT_ATTRIBUTES) {
    712         exists = XNVCTRLQueryValidTargetAttributeValues64(dpy, info,
    713                                                           target_type,
    714                                                           target_id,
    715                                                           display_mask,
    716                                                           attribute,
    717                                                           values);
    718     } else {
    719         exists = XNVCTRLQueryValidTargetAttributeValues32(dpy, info,
    720                                                           target_type,
    721                                                           target_id,
    722                                                           display_mask,
    723                                                           attribute,
    724                                                           values);
    725     }
    726     return exists;
    727 }
    728 
    729 
    730 Bool XNVCTRLQueryValidAttributeValues (
    731     Display *dpy,
    732     int screen,
    733     unsigned int display_mask,
    734     unsigned int attribute,
    735     NVCTRLAttributeValidValuesRec *values
    736 ){
    737     return XNVCTRLQueryValidTargetAttributeValues(dpy,
    738                                                   NV_CTRL_TARGET_TYPE_X_SCREEN,
    739                                                   screen, display_mask,
    740                                                   attribute, values);
    741 }
    742 
    743 
    744 static Bool QueryAttributePermissionsInternal (
    745     Display *dpy,
    746     unsigned int attribute,
    747     NVCTRLAttributePermissionsRec *permissions,
    748     unsigned int reqType
    749 ){
    750     XExtDisplayInfo *info = find_display (dpy);
    751     xnvCtrlQueryAttributePermissionsReply rep;
    752     xnvCtrlQueryAttributePermissionsReq *req;
    753     Bool exists;
    754 
    755     if(!XextHasExtension(info))
    756         return False;
    757 
    758     XNVCTRLCheckExtension (dpy, info, False);
    759 
    760     LockDisplay(dpy);
    761     GetReq(nvCtrlQueryAttributePermissions, req);
    762     req->reqType = info->codes->major_opcode;
    763     req->nvReqType = reqType;
    764     req->attribute = attribute;
    765     if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
    766         UnlockDisplay (dpy);
    767         SyncHandle();
    768         return False;
    769     }
    770     exists = rep.flags;
    771     if (exists && permissions) {
    772         permissions->type = rep.attr_type;
    773         permissions->permissions = rep.perms;
    774     }
    775     UnlockDisplay(dpy);
    776     SyncHandle();
    777     return exists;
    778 }
    779 
    780 
    781 Bool XNVCTRLQueryAttributePermissions (
    782     Display *dpy,
    783     unsigned int attribute,
    784     NVCTRLAttributePermissionsRec *permissions
    785 ){
    786     return QueryAttributePermissionsInternal(dpy,
    787                                              attribute,
    788                                              permissions,
    789                                              X_nvCtrlQueryAttributePermissions);
    790 }
    791 
    792 
    793 Bool XNVCTRLQueryStringAttributePermissions (
    794     Display *dpy,
    795     unsigned int attribute,
    796     NVCTRLAttributePermissionsRec *permissions
    797 ){
    798     return QueryAttributePermissionsInternal(dpy,
    799                                              attribute,
    800                                              permissions,
    801                                              X_nvCtrlQueryStringAttributePermissions);
    802 }
    803 
    804 
    805 Bool XNVCTRLQueryBinaryDataAttributePermissions (
    806     Display *dpy,
    807     unsigned int attribute,
    808     NVCTRLAttributePermissionsRec *permissions
    809 ){
    810     return QueryAttributePermissionsInternal(dpy,
    811                                              attribute,
    812                                              permissions,
    813                                              X_nvCtrlQueryBinaryDataAttributePermissions);
    814 }
    815 
    816 
    817 Bool XNVCTRLQueryStringOperationAttributePermissions (
    818     Display *dpy,
    819     unsigned int attribute,
    820     NVCTRLAttributePermissionsRec *permissions
    821 ){
    822     return QueryAttributePermissionsInternal(dpy,
    823                                              attribute,
    824                                              permissions,
    825                                              X_nvCtrlQueryStringOperationAttributePermissions);
    826 }
    827 
    828 
    829 void XNVCTRLSetGvoColorConversion (
    830     Display *dpy,
    831     int screen,
    832     float colorMatrix[3][3],
    833     float colorOffset[3],
    834     float colorScale[3]
    835 ){
    836     XExtDisplayInfo *info = find_display (dpy);
    837     xnvCtrlSetGvoColorConversionReq *req;
    838 
    839     XNVCTRLSimpleCheckExtension (dpy, info);
    840 
    841     LockDisplay (dpy);
    842     GetReq (nvCtrlSetGvoColorConversion, req);
    843     req->reqType = info->codes->major_opcode;
    844     req->nvReqType = X_nvCtrlSetGvoColorConversion;
    845     req->screen = screen;
    846 
    847     req->cscMatrix_y_r = colorMatrix[0][0];
    848     req->cscMatrix_y_g = colorMatrix[0][1];
    849     req->cscMatrix_y_b = colorMatrix[0][2];
    850 
    851     req->cscMatrix_cr_r = colorMatrix[1][0];
    852     req->cscMatrix_cr_g = colorMatrix[1][1];
    853     req->cscMatrix_cr_b = colorMatrix[1][2];
    854 
    855     req->cscMatrix_cb_r = colorMatrix[2][0];
    856     req->cscMatrix_cb_g = colorMatrix[2][1];
    857     req->cscMatrix_cb_b = colorMatrix[2][2];
    858 
    859     req->cscOffset_y  = colorOffset[0];
    860     req->cscOffset_cr = colorOffset[1];
    861     req->cscOffset_cb = colorOffset[2];
    862 
    863     req->cscScale_y  = colorScale[0];
    864     req->cscScale_cr = colorScale[1];
    865     req->cscScale_cb = colorScale[2];
    866 
    867     UnlockDisplay (dpy);
    868     SyncHandle ();
    869 }
    870 
    871 
    872 Bool XNVCTRLQueryGvoColorConversion (
    873     Display *dpy,
    874     int screen,
    875     float colorMatrix[3][3],
    876     float colorOffset[3],
    877     float colorScale[3]
    878 ){
    879     XExtDisplayInfo *info = find_display (dpy);
    880     xnvCtrlQueryGvoColorConversionReply rep;
    881     xnvCtrlQueryGvoColorConversionReq *req;
    882 
    883     if(!XextHasExtension(info))
    884         return False;
    885 
    886     XNVCTRLCheckExtension (dpy, info, False);
    887 
    888     LockDisplay (dpy);
    889 
    890     GetReq (nvCtrlQueryGvoColorConversion, req);
    891     req->reqType = info->codes->major_opcode;
    892     req->nvReqType = X_nvCtrlQueryGvoColorConversion;
    893     req->screen = screen;
    894 
    895     if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
    896         UnlockDisplay (dpy);
    897         SyncHandle ();
    898         return False;
    899     }
    900 
    901     _XRead(dpy, (char *)(colorMatrix), 36);
    902     _XRead(dpy, (char *)(colorOffset), 12);
    903     _XRead(dpy, (char *)(colorScale), 12);
    904 
    905     UnlockDisplay (dpy);
    906     SyncHandle ();
    907 
    908     return True;
    909 }
    910 
    911 
    912 Bool XNVCtrlSelectTargetNotify (
    913     Display *dpy,
    914     int target_type,
    915     int target_id,
    916     int notify_type,
    917     Bool onoff
    918 ){
    919     XExtDisplayInfo *info = find_display (dpy);
    920     xnvCtrlSelectTargetNotifyReq *req;
    921 
    922     if(!XextHasExtension (info))
    923         return False;
    924 
    925     XNVCTRLCheckExtension (dpy, info, False);
    926 
    927     LockDisplay (dpy);
    928     GetReq (nvCtrlSelectTargetNotify, req);
    929     req->reqType = info->codes->major_opcode;
    930     req->nvReqType = X_nvCtrlSelectTargetNotify;
    931     req->target_type = target_type;
    932     req->target_id = target_id;
    933     req->notifyType = notify_type;
    934     req->onoff = onoff;
    935     UnlockDisplay (dpy);
    936     SyncHandle ();
    937 
    938     return True;
    939 }
    940 
    941 
    942 Bool XNVCtrlSelectNotify (
    943     Display *dpy,
    944     int screen,
    945     int type,
    946     Bool onoff
    947 ){
    948     XExtDisplayInfo *info = find_display (dpy);
    949     xnvCtrlSelectNotifyReq *req;
    950 
    951     if(!XextHasExtension (info))
    952         return False;
    953 
    954     XNVCTRLCheckExtension (dpy, info, False);
    955 
    956     LockDisplay (dpy);
    957     GetReq (nvCtrlSelectNotify, req);
    958     req->reqType = info->codes->major_opcode;
    959     req->nvReqType = X_nvCtrlSelectNotify;
    960     req->screen = screen;
    961     req->notifyType = type;
    962     req->onoff = onoff;
    963     UnlockDisplay (dpy);
    964     SyncHandle ();
    965 
    966     return True;
    967 }
    968 
    969 Bool XNVCTRLQueryTargetBinaryData (
    970     Display *dpy,
    971     int target_type,
    972     int target_id,
    973     unsigned int display_mask,
    974     unsigned int attribute,
    975     unsigned char **ptr,
    976     int *len
    977 ){
    978     XExtDisplayInfo *info = find_display (dpy);
    979     xnvCtrlQueryBinaryDataReply rep;
    980     xnvCtrlQueryBinaryDataReq   *req;
    981     Bool exists;
    982     int length, numbytes, slop;
    983 
    984     if (!ptr) return False;
    985 
    986     if(!XextHasExtension(info))
    987         return False;
    988 
    989     XNVCTRLCheckExtension (dpy, info, False);
    990     XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
    991 
    992     LockDisplay (dpy);
    993     GetReq (nvCtrlQueryBinaryData, req);
    994     req->reqType = info->codes->major_opcode;
    995     req->nvReqType = X_nvCtrlQueryBinaryData;
    996     req->target_type = target_type;
    997     req->target_id = target_id;
    998     req->display_mask = display_mask;
    999     req->attribute = attribute;
   1000     if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
   1001         UnlockDisplay (dpy);
   1002         SyncHandle ();
   1003         return False;
   1004     }
   1005     length = rep.length;
   1006     numbytes = rep.n;
   1007     slop = numbytes & 3;
   1008     exists = rep.flags;
   1009     if (exists) {
   1010         *ptr = (unsigned char *) Xmalloc(numbytes);
   1011     }
   1012     if (!exists || !*ptr) {
   1013         _XEatData(dpy, length);
   1014         UnlockDisplay (dpy);
   1015         SyncHandle ();
   1016         return False;
   1017     } else {
   1018         _XRead(dpy, (char *) *ptr, numbytes);
   1019         if (slop) _XEatData(dpy, 4-slop);
   1020     }
   1021     if (len) *len = numbytes;
   1022     UnlockDisplay (dpy);
   1023     SyncHandle ();
   1024     return exists;
   1025 }
   1026 
   1027 Bool XNVCTRLQueryBinaryData (
   1028     Display *dpy,
   1029     int screen,
   1030     unsigned int display_mask,
   1031     unsigned int attribute,
   1032     unsigned char **ptr,
   1033     int *len
   1034 ){
   1035     return XNVCTRLQueryTargetBinaryData(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
   1036                                         screen, display_mask,
   1037                                         attribute, ptr, len);
   1038 }
   1039 
   1040 Bool XNVCTRLStringOperation (
   1041     Display *dpy,
   1042     int target_type,
   1043     int target_id,
   1044     unsigned int display_mask,
   1045     unsigned int attribute,
   1046     char *pIn,
   1047     char **ppOut
   1048 ) {
   1049     XExtDisplayInfo *info = find_display(dpy);
   1050     xnvCtrlStringOperationReq *req;
   1051     xnvCtrlStringOperationReply rep;
   1052     Bool ret;
   1053     int inSize, outSize, length, slop;
   1054 
   1055     if (!XextHasExtension(info))
   1056         return False;
   1057 
   1058     if (!ppOut)
   1059         return False;
   1060 
   1061     *ppOut = NULL;
   1062 
   1063     XNVCTRLCheckExtension(dpy, info, False);
   1064     XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
   1065 
   1066     if (pIn) {
   1067         inSize = strlen(pIn) + 1;
   1068     } else {
   1069         inSize = 0;
   1070     }
   1071 
   1072     LockDisplay(dpy);
   1073     GetReq(nvCtrlStringOperation, req);
   1074 
   1075     req->reqType = info->codes->major_opcode;
   1076     req->nvReqType = X_nvCtrlStringOperation;
   1077     req->target_type = target_type;
   1078     req->target_id = target_id;
   1079     req->display_mask = display_mask;
   1080     req->attribute = attribute;
   1081 
   1082     req->length += ((inSize + 3) & ~3) >> 2;
   1083     req->num_bytes = inSize;
   1084 
   1085     if (pIn) {
   1086         Data(dpy, pIn, inSize);
   1087     }
   1088 
   1089     if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
   1090         UnlockDisplay(dpy);
   1091         SyncHandle();
   1092         return False;
   1093     }
   1094 
   1095     length = rep.length;
   1096     outSize = rep.num_bytes;
   1097     slop = outSize & 3;
   1098 
   1099     if (outSize) *ppOut = (char *) Xmalloc(outSize);
   1100 
   1101     if (!*ppOut) {
   1102         _XEatData(dpy, length);
   1103     } else {
   1104         _XRead(dpy, (char *) *ppOut, outSize);
   1105         if (slop) _XEatData(dpy, 4-slop);
   1106     }
   1107 
   1108     ret = rep.ret;
   1109 
   1110     UnlockDisplay(dpy);
   1111     SyncHandle();
   1112 
   1113     return ret;
   1114 }
   1115 
   1116 
   1117 static Bool wire_to_event (Display *dpy, XEvent *host, xEvent *wire)
   1118 {
   1119     XExtDisplayInfo *info = find_display (dpy);
   1120     XNVCtrlEvent *re;
   1121     xnvctrlEvent *event;
   1122     XNVCtrlEventTarget *reTarget;
   1123     xnvctrlEventTarget *eventTarget;
   1124     XNVCtrlEventTargetAvailability *reTargetAvailability;
   1125     XNVCtrlStringEventTarget *reTargetString;
   1126     XNVCtrlBinaryEventTarget *reTargetBinary;
   1127 
   1128     XNVCTRLCheckExtension (dpy, info, False);
   1129 
   1130     switch ((wire->u.u.type & 0x7F) - info->codes->first_event) {
   1131     case ATTRIBUTE_CHANGED_EVENT:
   1132         re = (XNVCtrlEvent *) host;
   1133         event = (xnvctrlEvent *) wire;
   1134         re->attribute_changed.type = event->u.u.type & 0x7F;
   1135         re->attribute_changed.serial =
   1136             _XSetLastRequestRead(dpy, (xGenericReply*) event);
   1137         re->attribute_changed.send_event = ((event->u.u.type & 0x80) != 0);
   1138         re->attribute_changed.display = dpy;
   1139         re->attribute_changed.time = event->u.attribute_changed.time;
   1140         re->attribute_changed.screen = event->u.attribute_changed.screen;
   1141         re->attribute_changed.display_mask =
   1142             event->u.attribute_changed.display_mask;
   1143         re->attribute_changed.attribute = event->u.attribute_changed.attribute;
   1144         re->attribute_changed.value = event->u.attribute_changed.value;
   1145         break;
   1146     case TARGET_ATTRIBUTE_CHANGED_EVENT:
   1147         reTarget = (XNVCtrlEventTarget *) host;
   1148         eventTarget = (xnvctrlEventTarget *) wire;
   1149         reTarget->attribute_changed.type = eventTarget->u.u.type & 0x7F;
   1150         reTarget->attribute_changed.serial =
   1151             _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
   1152         reTarget->attribute_changed.send_event =
   1153             ((eventTarget->u.u.type & 0x80) != 0);
   1154         reTarget->attribute_changed.display = dpy;
   1155         reTarget->attribute_changed.time =
   1156             eventTarget->u.attribute_changed.time;
   1157         reTarget->attribute_changed.target_type =
   1158             eventTarget->u.attribute_changed.target_type;
   1159         reTarget->attribute_changed.target_id =
   1160             eventTarget->u.attribute_changed.target_id;
   1161         reTarget->attribute_changed.display_mask =
   1162             eventTarget->u.attribute_changed.display_mask;
   1163         reTarget->attribute_changed.attribute =
   1164             eventTarget->u.attribute_changed.attribute;
   1165         reTarget->attribute_changed.value =
   1166             eventTarget->u.attribute_changed.value;
   1167         break;
   1168     case TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENT:
   1169         reTargetAvailability = (XNVCtrlEventTargetAvailability *) host;
   1170         eventTarget = (xnvctrlEventTarget *) wire;
   1171         reTargetAvailability->attribute_changed.type =
   1172             eventTarget->u.u.type & 0x7F;
   1173         reTargetAvailability->attribute_changed.serial =
   1174             _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
   1175         reTargetAvailability->attribute_changed.send_event =
   1176             ((eventTarget->u.u.type & 0x80) != 0);
   1177         reTargetAvailability->attribute_changed.display = dpy;
   1178         reTargetAvailability->attribute_changed.time =
   1179             eventTarget->u.availability_changed.time;
   1180         reTargetAvailability->attribute_changed.target_type =
   1181             eventTarget->u.availability_changed.target_type;
   1182         reTargetAvailability->attribute_changed.target_id =
   1183             eventTarget->u.availability_changed.target_id;
   1184         reTargetAvailability->attribute_changed.display_mask =
   1185             eventTarget->u.availability_changed.display_mask;
   1186         reTargetAvailability->attribute_changed.attribute =
   1187             eventTarget->u.availability_changed.attribute;
   1188         reTargetAvailability->attribute_changed.availability =
   1189             eventTarget->u.availability_changed.availability;
   1190         reTargetAvailability->attribute_changed.value =
   1191             eventTarget->u.availability_changed.value;
   1192         break;
   1193     case TARGET_STRING_ATTRIBUTE_CHANGED_EVENT:
   1194         reTargetString = (XNVCtrlStringEventTarget *) host;
   1195         eventTarget = (xnvctrlEventTarget *) wire;
   1196         reTargetString->attribute_changed.type = eventTarget->u.u.type & 0x7F;
   1197         reTargetString->attribute_changed.serial =
   1198             _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
   1199         reTargetString->attribute_changed.send_event =
   1200             ((eventTarget->u.u.type & 0x80) != 0);
   1201         reTargetString->attribute_changed.display = dpy;
   1202         reTargetString->attribute_changed.time =
   1203             eventTarget->u.attribute_changed.time;
   1204         reTargetString->attribute_changed.target_type =
   1205             eventTarget->u.attribute_changed.target_type;
   1206         reTargetString->attribute_changed.target_id =
   1207             eventTarget->u.attribute_changed.target_id;
   1208         reTargetString->attribute_changed.display_mask =
   1209             eventTarget->u.attribute_changed.display_mask;
   1210         reTargetString->attribute_changed.attribute =
   1211             eventTarget->u.attribute_changed.attribute;
   1212         break;
   1213     case TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT:
   1214         reTargetBinary = (XNVCtrlBinaryEventTarget *) host;
   1215         eventTarget = (xnvctrlEventTarget *) wire;
   1216         reTargetBinary->attribute_changed.type = eventTarget->u.u.type & 0x7F;
   1217         reTargetBinary->attribute_changed.serial =
   1218             _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
   1219         reTargetBinary->attribute_changed.send_event =
   1220             ((eventTarget->u.u.type & 0x80) != 0);
   1221         reTargetBinary->attribute_changed.display = dpy;
   1222         reTargetBinary->attribute_changed.time =
   1223             eventTarget->u.attribute_changed.time;
   1224         reTargetBinary->attribute_changed.target_type =
   1225             eventTarget->u.attribute_changed.target_type;
   1226         reTargetBinary->attribute_changed.target_id =
   1227             eventTarget->u.attribute_changed.target_id;
   1228         reTargetBinary->attribute_changed.display_mask =
   1229             eventTarget->u.attribute_changed.display_mask;
   1230         reTargetBinary->attribute_changed.attribute =
   1231             eventTarget->u.attribute_changed.attribute;
   1232         break;
   1233 
   1234     default:
   1235         return False;
   1236     }
   1237 
   1238     return True;
   1239 }
   1240 
   1241