← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/driclient/src/XF86dri.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/driclient/src/XF86dri.c
 
1
/**************************************************************************
 
2
 
 
3
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
 
4
Copyright 2000 VA Linux Systems, Inc.
 
5
All Rights Reserved.
 
6
 
 
7
Permission is hereby granted, free of charge, to any person obtaining a
 
8
copy of this software and associated documentation files (the
 
9
"Software"), to deal in the Software without restriction, including
 
10
without limitation the rights to use, copy, modify, merge, publish,
 
11
distribute, sub license, and/or sell copies of the Software, and to
 
12
permit persons to whom the Software is furnished to do so, subject to
 
13
the following conditions:
 
14
 
 
15
The above copyright notice and this permission notice (including the
 
16
next paragraph) shall be included in all copies or substantial portions
 
17
of the Software.
 
18
 
 
19
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
20
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
21
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 
22
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
 
23
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 
24
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 
25
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
26
 
 
27
**************************************************************************/
 
28
 
 
29
/*
 
30
 * Authors:
 
31
 *   Kevin E. Martin <martin@valinux.com>
 
32
 *   Jens Owen <jens@tungstengraphics.com>
 
33
 *   Rickard E. (Rik) Faith <faith@valinux.com>
 
34
 *
 
35
 */
 
36
 
 
37
/* THIS IS NOT AN X CONSORTIUM STANDARD */
 
38
 
 
39
#include <X11/Xlibint.h>
 
40
#include <X11/extensions/Xext.h>
 
41
#include <X11/extensions/extutil.h>
 
42
#include "xf86dristr.h"
 
43
 
 
44
static XExtensionInfo _xf86dri_info_data;
 
45
static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;
 
46
static char xf86dri_extension_name[] = XF86DRINAME;
 
47
 
 
48
#define XF86DRICheckExtension(dpy,i,val) \
 
49
  XextCheckExtension (dpy, i, xf86dri_extension_name, val)
 
50
 
 
51
/*****************************************************************************
 
52
 *                                                                           *
 
53
 *                         private utility routines                          *
 
54
 *                                                                           *
 
55
 *****************************************************************************/
 
56
 
 
57
static int close_display(Display *dpy, XExtCodes *extCodes);
 
58
static /* const */ XExtensionHooks xf86dri_extension_hooks = {
 
59
    NULL,                               /* create_gc */
 
60
    NULL,                               /* copy_gc */
 
61
    NULL,                               /* flush_gc */
 
62
    NULL,                               /* free_gc */
 
63
    NULL,                               /* create_font */
 
64
    NULL,                               /* free_font */
 
65
    close_display,                      /* close_display */
 
66
    NULL,                               /* wire_to_event */
 
67
    NULL,                               /* event_to_wire */
 
68
    NULL,                               /* error */
 
69
    NULL,                               /* error_string */
 
70
};
 
71
 
 
72
static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info, 
 
73
                                   xf86dri_extension_name, 
 
74
                                   &xf86dri_extension_hooks, 
 
75
                                   0, NULL)
 
76
 
 
77
static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
 
78
 
 
79
 
 
80
/*****************************************************************************
 
81
 *                                                                           *
 
82
 *                  public XFree86-DRI Extension routines                    *
 
83
 *                                                                           *
 
84
 *****************************************************************************/
 
85
 
 
86
#if 0
 
87
#include <stdio.h>
 
88
#define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);
 
89
#else
 
90
#define TRACE(msg)
 
91
#endif
 
92
 
 
93
#define PUBLIC
 
94
 
 
95
PUBLIC Bool XF86DRIQueryExtension (dpy, event_basep, error_basep)
 
96
    Display *dpy;
 
97
    int *event_basep, *error_basep;
 
98
{
 
99
    XExtDisplayInfo *info = find_display (dpy);
 
100
 
 
101
    TRACE("QueryExtension...");
 
102
    if (XextHasExtension(info)) {
 
103
        *event_basep = info->codes->first_event;
 
104
        *error_basep = info->codes->first_error;
 
105
        TRACE("QueryExtension... return True");
 
106
        return True;
 
107
    } else {
 
108
        TRACE("QueryExtension... return False");
 
109
        return False;
 
110
    }
 
111
}
 
112
 
 
113
PUBLIC Bool XF86DRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
 
114
    Display* dpy;
 
115
    int* majorVersion; 
 
116
    int* minorVersion;
 
117
    int* patchVersion;
 
118
{
 
119
    XExtDisplayInfo *info = find_display (dpy);
 
120
    xXF86DRIQueryVersionReply rep;
 
121
    xXF86DRIQueryVersionReq *req;
 
122
 
 
123
    TRACE("QueryVersion...");
 
124
    XF86DRICheckExtension (dpy, info, False);
 
125
 
 
126
    LockDisplay(dpy);
 
127
    GetReq(XF86DRIQueryVersion, req);
 
128
    req->reqType = info->codes->major_opcode;
 
129
    req->driReqType = X_XF86DRIQueryVersion;
 
130
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
131
        UnlockDisplay(dpy);
 
132
        SyncHandle();
 
133
        TRACE("QueryVersion... return False");
 
134
        return False;
 
135
    }
 
136
    *majorVersion = rep.majorVersion;
 
137
    *minorVersion = rep.minorVersion;
 
138
    *patchVersion = rep.patchVersion;
 
139
    UnlockDisplay(dpy);
 
140
    SyncHandle();
 
141
    TRACE("QueryVersion... return True");
 
142
    return True;
 
143
}
 
144
 
 
145
PUBLIC Bool XF86DRIQueryDirectRenderingCapable(dpy, screen, isCapable)
 
146
    Display* dpy;
 
147
    int screen;
 
148
    Bool* isCapable;
 
149
{
 
150
    XExtDisplayInfo *info = find_display (dpy);
 
151
    xXF86DRIQueryDirectRenderingCapableReply rep;
 
152
    xXF86DRIQueryDirectRenderingCapableReq *req;
 
153
 
 
154
    TRACE("QueryDirectRenderingCapable...");
 
155
    XF86DRICheckExtension (dpy, info, False);
 
156
 
 
157
    LockDisplay(dpy);
 
158
    GetReq(XF86DRIQueryDirectRenderingCapable, req);
 
159
    req->reqType = info->codes->major_opcode;
 
160
    req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
 
161
    req->screen = screen;
 
162
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
163
        UnlockDisplay(dpy);
 
164
        SyncHandle();
 
165
        TRACE("QueryDirectRenderingCapable... return False");
 
166
        return False;
 
167
    }
 
168
    *isCapable = rep.isCapable;
 
169
    UnlockDisplay(dpy);
 
170
    SyncHandle();
 
171
    TRACE("QueryDirectRenderingCapable... return True");
 
172
    return True;
 
173
}
 
174
 
 
175
PUBLIC Bool XF86DRIOpenConnection(dpy, screen, hSAREA, busIdString)
 
176
    Display* dpy;
 
177
    int screen;
 
178
    drm_handle_t * hSAREA;
 
179
    char **busIdString;
 
180
{
 
181
    XExtDisplayInfo *info = find_display (dpy);
 
182
    xXF86DRIOpenConnectionReply rep;
 
183
    xXF86DRIOpenConnectionReq *req;
 
184
 
 
185
    TRACE("OpenConnection...");
 
186
    XF86DRICheckExtension (dpy, info, False);
 
187
 
 
188
    LockDisplay(dpy);
 
189
    GetReq(XF86DRIOpenConnection, req);
 
190
    req->reqType = info->codes->major_opcode;
 
191
    req->driReqType = X_XF86DRIOpenConnection;
 
192
    req->screen = screen;
 
193
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
194
        UnlockDisplay(dpy);
 
195
        SyncHandle();
 
196
        TRACE("OpenConnection... return False");
 
197
        return False;
 
198
    }
 
199
 
 
200
    *hSAREA = rep.hSAREALow;
 
201
    if (sizeof(drm_handle_t) == 8) {
 
202
       int shift = 32; /* var to prevent warning on next line */
 
203
       *hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;
 
204
    }
 
205
 
 
206
    if (rep.length) {
 
207
        if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
 
208
            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
 
209
            UnlockDisplay(dpy);
 
210
            SyncHandle();
 
211
            TRACE("OpenConnection... return False");
 
212
            return False;
 
213
        }
 
214
        _XReadPad(dpy, *busIdString, rep.busIdStringLength);
 
215
    } else {
 
216
        *busIdString = NULL;
 
217
    }
 
218
    UnlockDisplay(dpy);
 
219
    SyncHandle();
 
220
    TRACE("OpenConnection... return True");
 
221
    return True;
 
222
}
 
223
 
 
224
PUBLIC Bool XF86DRIAuthConnection(dpy, screen, magic)
 
225
    Display* dpy;
 
226
    int screen;
 
227
    drm_magic_t magic;
 
228
{
 
229
    XExtDisplayInfo *info = find_display (dpy);
 
230
    xXF86DRIAuthConnectionReq *req;
 
231
    xXF86DRIAuthConnectionReply rep;
 
232
 
 
233
    TRACE("AuthConnection...");
 
234
    XF86DRICheckExtension (dpy, info, False);
 
235
 
 
236
    LockDisplay(dpy);
 
237
    GetReq(XF86DRIAuthConnection, req);
 
238
    req->reqType = info->codes->major_opcode;
 
239
    req->driReqType = X_XF86DRIAuthConnection;
 
240
    req->screen = screen;
 
241
    req->magic = magic;
 
242
    rep.authenticated = 0;
 
243
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
 
244
        UnlockDisplay(dpy);
 
245
        SyncHandle();
 
246
        TRACE("AuthConnection... return False");
 
247
        return False;
 
248
    }
 
249
    UnlockDisplay(dpy);
 
250
    SyncHandle();
 
251
    TRACE("AuthConnection... return True");
 
252
    return True;
 
253
}
 
254
 
 
255
PUBLIC Bool XF86DRICloseConnection(dpy, screen)
 
256
    Display* dpy;
 
257
    int screen;
 
258
{
 
259
    XExtDisplayInfo *info = find_display (dpy);
 
260
    xXF86DRICloseConnectionReq *req;
 
261
 
 
262
    TRACE("CloseConnection...");
 
263
 
 
264
    XF86DRICheckExtension (dpy, info, False);
 
265
 
 
266
    LockDisplay(dpy);
 
267
    GetReq(XF86DRICloseConnection, req);
 
268
    req->reqType = info->codes->major_opcode;
 
269
    req->driReqType = X_XF86DRICloseConnection;
 
270
    req->screen = screen;
 
271
    UnlockDisplay(dpy);
 
272
    SyncHandle();
 
273
    TRACE("CloseConnection... return True");
 
274
    return True;
 
275
}
 
276
 
 
277
PUBLIC Bool XF86DRIGetClientDriverName(dpy, screen, ddxDriverMajorVersion, 
 
278
        ddxDriverMinorVersion, ddxDriverPatchVersion, clientDriverName)
 
279
    Display* dpy;
 
280
    int screen;
 
281
    int* ddxDriverMajorVersion;
 
282
    int* ddxDriverMinorVersion;
 
283
    int* ddxDriverPatchVersion;
 
284
    char** clientDriverName;
 
285
{
 
286
    XExtDisplayInfo *info = find_display (dpy);
 
287
    xXF86DRIGetClientDriverNameReply rep;
 
288
    xXF86DRIGetClientDriverNameReq *req;
 
289
 
 
290
    TRACE("GetClientDriverName...");
 
291
    XF86DRICheckExtension (dpy, info, False);
 
292
 
 
293
    LockDisplay(dpy);
 
294
    GetReq(XF86DRIGetClientDriverName, req);
 
295
    req->reqType = info->codes->major_opcode;
 
296
    req->driReqType = X_XF86DRIGetClientDriverName;
 
297
    req->screen = screen;
 
298
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
299
        UnlockDisplay(dpy);
 
300
        SyncHandle();
 
301
        TRACE("GetClientDriverName... return False");
 
302
        return False;
 
303
    }
 
304
 
 
305
    *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
 
306
    *ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
 
307
    *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
 
308
 
 
309
    if (rep.length) {
 
310
        if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
 
311
            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
 
312
            UnlockDisplay(dpy);
 
313
            SyncHandle();
 
314
            TRACE("GetClientDriverName... return False");
 
315
            return False;
 
316
        }
 
317
        _XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
 
318
    } else {
 
319
        *clientDriverName = NULL;
 
320
    }
 
321
    UnlockDisplay(dpy);
 
322
    SyncHandle();
 
323
    TRACE("GetClientDriverName... return True");
 
324
    return True;
 
325
}
 
326
 
 
327
PUBLIC Bool XF86DRICreateContextWithConfig(dpy, screen, configID, context,
 
328
        hHWContext)
 
329
    Display* dpy;
 
330
    int screen;
 
331
    int configID;
 
332
    XID* context;
 
333
    drm_context_t * hHWContext;
 
334
{
 
335
    XExtDisplayInfo *info = find_display (dpy);
 
336
    xXF86DRICreateContextReply rep;
 
337
    xXF86DRICreateContextReq *req;
 
338
 
 
339
    TRACE("CreateContext...");
 
340
    XF86DRICheckExtension (dpy, info, False);
 
341
 
 
342
    LockDisplay(dpy);
 
343
    GetReq(XF86DRICreateContext, req);
 
344
    req->reqType = info->codes->major_opcode;
 
345
    req->driReqType = X_XF86DRICreateContext;
 
346
    req->visual = configID;
 
347
    req->screen = screen;
 
348
    *context = XAllocID(dpy);
 
349
    req->context = *context;
 
350
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
351
        UnlockDisplay(dpy);
 
352
        SyncHandle();
 
353
        TRACE("CreateContext... return False");
 
354
        return False;
 
355
    }
 
356
    *hHWContext = rep.hHWContext;
 
357
    UnlockDisplay(dpy);
 
358
    SyncHandle();
 
359
    TRACE("CreateContext... return True");
 
360
    return True;
 
361
}
 
362
 
 
363
PUBLIC Bool XF86DRICreateContext(dpy, screen, visual, context, hHWContext)
 
364
    Display* dpy;
 
365
    int screen;
 
366
    Visual* visual;
 
367
    XID* context;
 
368
    drm_context_t * hHWContext;
 
369
{
 
370
    return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
 
371
                                           context, hHWContext );
 
372
}
 
373
 
 
374
PUBLIC Bool XF86DRIDestroyContext( Display * ndpy, int screen, 
 
375
    XID context )
 
376
{
 
377
    Display * const dpy = (Display *) ndpy;
 
378
    XExtDisplayInfo *info = find_display (dpy);
 
379
    xXF86DRIDestroyContextReq *req;
 
380
 
 
381
    TRACE("DestroyContext...");
 
382
    XF86DRICheckExtension (dpy, info, False);
 
383
 
 
384
    LockDisplay(dpy);
 
385
    GetReq(XF86DRIDestroyContext, req);
 
386
    req->reqType = info->codes->major_opcode;
 
387
    req->driReqType = X_XF86DRIDestroyContext;
 
388
    req->screen = screen;
 
389
    req->context = context;
 
390
    UnlockDisplay(dpy);
 
391
    SyncHandle();
 
392
    TRACE("DestroyContext... return True");
 
393
    return True;
 
394
}
 
395
 
 
396
PUBLIC Bool XF86DRICreateDrawable( Display * ndpy, int screen, 
 
397
    Drawable drawable, drm_drawable_t * hHWDrawable )
 
398
{
 
399
    Display * const dpy = (Display *) ndpy;
 
400
    XExtDisplayInfo *info = find_display (dpy);
 
401
    xXF86DRICreateDrawableReply rep;
 
402
    xXF86DRICreateDrawableReq *req;
 
403
 
 
404
    TRACE("CreateDrawable...");
 
405
    XF86DRICheckExtension (dpy, info, False);
 
406
 
 
407
    LockDisplay(dpy);
 
408
    GetReq(XF86DRICreateDrawable, req);
 
409
    req->reqType = info->codes->major_opcode;
 
410
    req->driReqType = X_XF86DRICreateDrawable;
 
411
    req->screen = screen;
 
412
    req->drawable = drawable;
 
413
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
414
        UnlockDisplay(dpy);
 
415
        SyncHandle();
 
416
        TRACE("CreateDrawable... return False");
 
417
        return False;
 
418
    }
 
419
    *hHWDrawable = rep.hHWDrawable;
 
420
    UnlockDisplay(dpy);
 
421
    SyncHandle();
 
422
    TRACE("CreateDrawable... return True");
 
423
    return True;
 
424
}
 
425
 
 
426
PUBLIC Bool XF86DRIDestroyDrawable( Display * ndpy, int screen,
 
427
    Drawable drawable )
 
428
{
 
429
    Display * const dpy = (Display *) ndpy;
 
430
    XExtDisplayInfo *info = find_display (dpy);
 
431
    xXF86DRIDestroyDrawableReq *req;
 
432
 
 
433
    TRACE("DestroyDrawable...");
 
434
    XF86DRICheckExtension (dpy, info, False);
 
435
 
 
436
    LockDisplay(dpy);
 
437
    GetReq(XF86DRIDestroyDrawable, req);
 
438
    req->reqType = info->codes->major_opcode;
 
439
    req->driReqType = X_XF86DRIDestroyDrawable;
 
440
    req->screen = screen;
 
441
    req->drawable = drawable;
 
442
    UnlockDisplay(dpy);
 
443
    SyncHandle();
 
444
    TRACE("DestroyDrawable... return True");
 
445
    return True;
 
446
}
 
447
 
 
448
PUBLIC Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
 
449
    unsigned int* index, unsigned int* stamp,
 
450
    int* X, int* Y, int* W, int* H,
 
451
    int* numClipRects, drm_clip_rect_t ** pClipRects,
 
452
    int* backX, int* backY,
 
453
    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
 
454
{
 
455
    XExtDisplayInfo *info = find_display (dpy);
 
456
    xXF86DRIGetDrawableInfoReply rep;
 
457
    xXF86DRIGetDrawableInfoReq *req;
 
458
    int total_rects;
 
459
 
 
460
    TRACE("GetDrawableInfo...");
 
461
    XF86DRICheckExtension (dpy, info, False);
 
462
 
 
463
    LockDisplay(dpy);
 
464
    GetReq(XF86DRIGetDrawableInfo, req);
 
465
    req->reqType = info->codes->major_opcode;
 
466
    req->driReqType = X_XF86DRIGetDrawableInfo;
 
467
    req->screen = screen;
 
468
    req->drawable = drawable;
 
469
 
 
470
    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 
 
471
    {
 
472
        UnlockDisplay(dpy);
 
473
        SyncHandle();
 
474
        TRACE("GetDrawableInfo... return False");
 
475
        return False;
 
476
    }
 
477
    *index = rep.drawableTableIndex;
 
478
    *stamp = rep.drawableTableStamp;
 
479
    *X = (int)rep.drawableX;
 
480
    *Y = (int)rep.drawableY;
 
481
    *W = (int)rep.drawableWidth;
 
482
    *H = (int)rep.drawableHeight;
 
483
    *numClipRects = rep.numClipRects;
 
484
    total_rects = *numClipRects;
 
485
 
 
486
    *backX = rep.backX;
 
487
    *backY = rep.backY;
 
488
    *numBackClipRects = rep.numBackClipRects;
 
489
    total_rects += *numBackClipRects;
 
490
 
 
491
#if 0
 
492
    /* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
 
493
     * backwards compatibility (Because of the >> 2 shift) but the fix
 
494
     * enables multi-threaded apps to work.
 
495
     */
 
496
    if (rep.length !=  ((((SIZEOF(xXF86DRIGetDrawableInfoReply) - 
 
497
                       SIZEOF(xGenericReply) + 
 
498
                       total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
 
499
        _XEatData(dpy, rep.length);
 
500
        UnlockDisplay(dpy);
 
501
        SyncHandle();
 
502
        TRACE("GetDrawableInfo... return False");
 
503
        return False;
 
504
    }
 
505
#endif
 
506
 
 
507
    if (*numClipRects) {
 
508
       int len = sizeof(drm_clip_rect_t) * (*numClipRects);
 
509
 
 
510
       *pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
 
511
       if (*pClipRects) 
 
512
          _XRead(dpy, (char*)*pClipRects, len);
 
513
    } else {
 
514
        *pClipRects = NULL;
 
515
    }
 
516
 
 
517
    if (*numBackClipRects) {
 
518
       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
 
519
 
 
520
       *pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
 
521
       if (*pBackClipRects) 
 
522
          _XRead(dpy, (char*)*pBackClipRects, len);
 
523
    } else {
 
524
        *pBackClipRects = NULL;
 
525
    }
 
526
 
 
527
    UnlockDisplay(dpy);
 
528
    SyncHandle();
 
529
    TRACE("GetDrawableInfo... return True");
 
530
    return True;
 
531
}
 
532
 
 
533
PUBLIC Bool XF86DRIGetDeviceInfo(dpy, screen, hFrameBuffer, 
 
534
        fbOrigin, fbSize, fbStride, devPrivateSize, pDevPrivate)
 
535
    Display* dpy;
 
536
    int screen;
 
537
    drm_handle_t * hFrameBuffer;
 
538
    int* fbOrigin;
 
539
    int* fbSize;
 
540
    int* fbStride;
 
541
    int* devPrivateSize;
 
542
    void** pDevPrivate;
 
543
{
 
544
    XExtDisplayInfo *info = find_display (dpy);
 
545
    xXF86DRIGetDeviceInfoReply rep;
 
546
    xXF86DRIGetDeviceInfoReq *req;
 
547
 
 
548
    TRACE("GetDeviceInfo...");
 
549
    XF86DRICheckExtension (dpy, info, False);
 
550
 
 
551
    LockDisplay(dpy);
 
552
    GetReq(XF86DRIGetDeviceInfo, req);
 
553
    req->reqType = info->codes->major_opcode;
 
554
    req->driReqType = X_XF86DRIGetDeviceInfo;
 
555
    req->screen = screen;
 
556
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
557
        UnlockDisplay(dpy);
 
558
        SyncHandle();
 
559
        TRACE("GetDeviceInfo... return False");
 
560
        return False;
 
561
    }
 
562
 
 
563
    *hFrameBuffer = rep.hFrameBufferLow;
 
564
    if (sizeof(drm_handle_t) == 8) {
 
565
       int shift = 32; /* var to prevent warning on next line */
 
566
       *hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
 
567
    }
 
568
 
 
569
    *fbOrigin = rep.framebufferOrigin;
 
570
    *fbSize = rep.framebufferSize;
 
571
    *fbStride = rep.framebufferStride;
 
572
    *devPrivateSize = rep.devPrivateSize;
 
573
 
 
574
    if (rep.length) {
 
575
        if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
 
576
            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
 
577
            UnlockDisplay(dpy);
 
578
            SyncHandle();
 
579
            TRACE("GetDeviceInfo... return False");
 
580
            return False;
 
581
        }
 
582
        _XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
 
583
    } else {
 
584
        *pDevPrivate = NULL;
 
585
    }
 
586
 
 
587
    UnlockDisplay(dpy);
 
588
    SyncHandle();
 
589
    TRACE("GetDeviceInfo... return True");
 
590
    return True;
 
591
}
 
592
 
 
593
PUBLIC Bool XF86DRIOpenFullScreen(dpy, screen, drawable)
 
594
    Display* dpy;
 
595
    int screen;
 
596
    Drawable drawable;
 
597
{
 
598
    /* This function and the underlying X protocol are deprecated.
 
599
     */
 
600
    (void) dpy;
 
601
    (void) screen;
 
602
    (void) drawable;
 
603
    return False;
 
604
}
 
605
 
 
606
PUBLIC Bool XF86DRICloseFullScreen(dpy, screen, drawable)
 
607
    Display* dpy;
 
608
    int screen;
 
609
    Drawable drawable;
 
610
{
 
611
    /* This function and the underlying X protocol are deprecated.
 
612
     */
 
613
    (void) dpy;
 
614
    (void) screen;
 
615
    (void) drawable;
 
616
    return True;
 
617
}
 
618