← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/lib/Xxf86dga/XF86DGA2.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/lib/Xxf86dga/XF86DGA2.c
 
1
/* $XFree86: xc/lib/Xxf86dga/XF86DGA2.c,v 1.21 2002/12/14 04:41:12 dawes Exp $ */
 
2
/*
 
3
 
 
4
Copyright (c) 1995  Jon Tombs
 
5
Copyright (c) 1995,1996  The XFree86 Project, Inc
 
6
 
 
7
*/
 
8
 
 
9
/* THIS IS NOT AN X CONSORTIUM STANDARD */
 
10
 
 
11
#ifdef __UNIXOS2__ /* needed here to override certain constants in X headers */
 
12
#define INCL_DOS
 
13
#define INCL_DOSIOCTL
 
14
#include <os2.h>
 
15
#endif
 
16
 
 
17
#define NEED_EVENTS
 
18
#define NEED_REPLIES
 
19
#include <X11/Xlibint.h>
 
20
#include <X11/extensions/xf86dga.h>
 
21
#include <X11/extensions/xf86dgastr.h>
 
22
#include <X11/extensions/Xext.h>
 
23
#include <X11/extensions/extutil.h>
 
24
#include <stdio.h>
 
25
 
 
26
 
 
27
/* If you change this, change the Bases[] array below as well */
 
28
#define MAX_HEADS 16
 
29
 
 
30
char *xdga_extension_name = XF86DGANAME;
 
31
 
 
32
static XExtensionInfo _xdga_info_data;
 
33
static XExtensionInfo *xdga_info = &_xdga_info_data;
 
34
 
 
35
 
 
36
Bool XDGAMapFramebuffer(int, char *, unsigned char*, CARD32, CARD32, CARD32);
 
37
void XDGAUnmapFramebuffer(int);
 
38
unsigned char* XDGAGetMappedMemory(int);
 
39
 
 
40
#define XDGACheckExtension(dpy,i,val) \
 
41
  XextCheckExtension (dpy, i, xdga_extension_name, val)
 
42
 
 
43
/*****************************************************************************
 
44
 *                                                                           *
 
45
 *                         private utility routines                          *
 
46
 *                                                                           *
 
47
 *****************************************************************************/
 
48
 
 
49
static int xdga_close_display(Display *dpy, XExtCodes *codes);
 
50
static Bool xdga_wire_to_event(Display *dpy, XEvent *event, xEvent *wire_ev);
 
51
static Status xdga_event_to_wire(Display *dpy, XEvent *event, xEvent *wire_ev);
 
52
 
 
53
static XExtensionHooks xdga_extension_hooks = {
 
54
    NULL,                               /* create_gc */
 
55
    NULL,                               /* copy_gc */
 
56
    NULL,                               /* flush_gc */
 
57
    NULL,                               /* free_gc */
 
58
    NULL,                               /* create_font */
 
59
    NULL,                               /* free_font */
 
60
    xdga_close_display,                 /* close_display */
 
61
    xdga_wire_to_event,                 /* wire_to_event */
 
62
    xdga_event_to_wire,                 /* event_to_wire */
 
63
    NULL,                               /* error */
 
64
    NULL,                               /* error_string */
 
65
};
 
66
 
 
67
static XEXT_GENERATE_CLOSE_DISPLAY (xdga_close_display, xdga_info)
 
68
 
 
69
 
 
70
XEXT_GENERATE_FIND_DISPLAY (xdga_find_display, xdga_info, 
 
71
                                   "XFree86-DGA", 
 
72
                                   &xdga_extension_hooks, 
 
73
                                   0, NULL)
 
74
 
 
75
 
 
76
static Status
 
77
xdga_event_to_wire(
 
78
  Display *dpy,
 
79
  XEvent *event,
 
80
  xEvent *wire_ev
 
81
){
 
82
    return True;
 
83
}
 
84
 
 
85
static Bool
 
86
xdga_wire_to_event(
 
87
  Display *dpy,
 
88
  XEvent *event,
 
89
  xEvent *wire_ev
 
90
){
 
91
  dgaEvent *wire = (dgaEvent *) wire_ev;
 
92
  XDGAButtonEvent *bevent;
 
93
  XDGAKeyEvent *kevent;
 
94
  XDGAMotionEvent *mevent;
 
95
  XExtDisplayInfo *info = xdga_find_display (dpy);
 
96
 
 
97
  XDGACheckExtension (dpy, info, False);
 
98
 
 
99
  switch((wire->u.u.type & 0x7f) - info->codes->first_event) {
 
100
  case MotionNotify:
 
101
        mevent = (XDGAMotionEvent*)event;
 
102
        mevent->type = wire->u.u.type & 0x7F;
 
103
        mevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);
 
104
        mevent->display = dpy;
 
105
        mevent->screen = wire->u.event.screen;
 
106
        mevent->time = wire->u.event.time;
 
107
        mevent->state = wire->u.event.state;
 
108
        mevent->dx = wire->u.event.dx;
 
109
        mevent->dy = wire->u.event.dy;
 
110
        return True;
 
111
  case ButtonPress:
 
112
  case ButtonRelease:
 
113
        bevent = (XDGAButtonEvent*)event;
 
114
        bevent->type = wire->u.u.type & 0x7F;
 
115
        bevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);
 
116
        bevent->display = dpy;
 
117
        bevent->screen = wire->u.event.screen;
 
118
        bevent->time = wire->u.event.time;
 
119
        bevent->state = wire->u.event.state;
 
120
        bevent->button = wire->u.u.detail;
 
121
        return True;
 
122
  case KeyPress:
 
123
  case KeyRelease:
 
124
        kevent = (XDGAKeyEvent*)event;
 
125
        kevent->type = wire->u.u.type & 0x7F;
 
126
        kevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);
 
127
        kevent->display = dpy;
 
128
        kevent->screen = wire->u.event.screen;
 
129
        kevent->time = wire->u.event.time;
 
130
        kevent->state = wire->u.event.state;
 
131
        kevent->keycode = wire->u.u.detail;
 
132
        return True;
 
133
  }
 
134
 
 
135
  return False;
 
136
}
 
137
 
 
138
 
 
139
Bool XDGAQueryExtension (
 
140
    Display *dpy,
 
141
    int *event_basep,
 
142
    int *error_basep
 
143
){
 
144
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
145
 
 
146
    if (XextHasExtension(info)) {
 
147
        *event_basep = info->codes->first_event;
 
148
        *error_basep = info->codes->first_error;
 
149
        return True;
 
150
    } else {
 
151
        return False;
 
152
    }
 
153
}
 
154
 
 
155
 
 
156
Bool XDGAQueryVersion(
 
157
    Display *dpy,
 
158
    int *majorVersion, 
 
159
    int *minorVersion
 
160
){
 
161
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
162
    xXDGAQueryVersionReply rep;
 
163
    xXDGAQueryVersionReq *req;
 
164
 
 
165
    XDGACheckExtension (dpy, info, False);
 
166
 
 
167
    LockDisplay(dpy);
 
168
    GetReq(XDGAQueryVersion, req);
 
169
    req->reqType = info->codes->major_opcode;
 
170
    req->dgaReqType = X_XDGAQueryVersion;
 
171
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
172
        UnlockDisplay(dpy);
 
173
        SyncHandle();
 
174
        return False;
 
175
    }
 
176
    *majorVersion = rep.majorVersion;
 
177
    *minorVersion = rep.minorVersion;
 
178
    UnlockDisplay(dpy);
 
179
    SyncHandle();
 
180
    if (*majorVersion >= 2)
 
181
    {
 
182
        int i, j;
 
183
 
 
184
        for (i = 0, j = info->codes->first_event;
 
185
             i < XF86DGANumberEvents;
 
186
             i++, j++) 
 
187
        {
 
188
            XESetWireToEvent (dpy, j, xdga_wire_to_event);
 
189
            XESetEventToWire (dpy, j, xdga_event_to_wire);
 
190
        }
 
191
        XDGASetClientVersion(dpy);
 
192
    }
 
193
    return True;
 
194
}
 
195
 
 
196
Bool XDGASetClientVersion(
 
197
    Display     *dpy
 
198
){
 
199
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
200
    xXDGASetClientVersionReq *req;
 
201
 
 
202
    XDGACheckExtension (dpy, info, False);
 
203
 
 
204
    LockDisplay(dpy);
 
205
    GetReq(XDGASetClientVersion, req);
 
206
    req->reqType = info->codes->major_opcode;
 
207
    req->dgaReqType = X_XDGASetClientVersion;
 
208
    req->major = XDGA_MAJOR_VERSION;
 
209
    req->minor = XDGA_MINOR_VERSION;
 
210
    UnlockDisplay(dpy);
 
211
    SyncHandle();
 
212
    return True;
 
213
}
 
214
 
 
215
Bool XDGAOpenFramebuffer(
 
216
    Display     *dpy,
 
217
    int         screen
 
218
){
 
219
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
220
    xXDGAOpenFramebufferReply rep;
 
221
    xXDGAOpenFramebufferReq *req;
 
222
    char *deviceName = NULL;
 
223
    Bool ret;
 
224
 
 
225
    XDGACheckExtension (dpy, info, False);
 
226
 
 
227
    LockDisplay(dpy);
 
228
    GetReq(XDGAOpenFramebuffer, req);
 
229
    req->reqType = info->codes->major_opcode;
 
230
    req->dgaReqType = X_XDGAOpenFramebuffer;
 
231
    req->screen = screen;
 
232
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
233
        UnlockDisplay(dpy);
 
234
        SyncHandle();
 
235
        return False;
 
236
    }
 
237
 
 
238
    if(rep.length) {
 
239
        deviceName = Xmalloc(rep.length << 2);
 
240
        _XRead(dpy, deviceName, rep.length << 2);
 
241
    }
 
242
 
 
243
    ret = XDGAMapFramebuffer(screen, deviceName,
 
244
                                (unsigned char*)(long)rep.mem1, 
 
245
                                rep.size, rep.offset, rep.extra);
 
246
 
 
247
    if(deviceName)
 
248
        Xfree(deviceName);      
 
249
 
 
250
    UnlockDisplay(dpy);
 
251
    SyncHandle();
 
252
    return ret;
 
253
}
 
254
 
 
255
void XDGACloseFramebuffer(
 
256
    Display     *dpy,
 
257
    int         screen
 
258
){
 
259
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
260
    xXDGACloseFramebufferReq *req;
 
261
 
 
262
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
263
 
 
264
    XDGAUnmapFramebuffer(screen);
 
265
 
 
266
    LockDisplay(dpy);
 
267
    GetReq(XDGACloseFramebuffer, req);
 
268
    req->reqType = info->codes->major_opcode;
 
269
    req->dgaReqType = X_XDGACloseFramebuffer;
 
270
    req->screen = screen;
 
271
    UnlockDisplay(dpy);
 
272
    SyncHandle();
 
273
}
 
274
 
 
275
 
 
276
 
 
277
XDGAMode* XDGAQueryModes(
 
278
    Display *dpy,
 
279
    int screen,
 
280
    int *num
 
281
){
 
282
    XExtDisplayInfo *dinfo = xdga_find_display (dpy);
 
283
    xXDGAQueryModesReply rep;
 
284
    xXDGAQueryModesReq *req;
 
285
    XDGAMode *modes = NULL;
 
286
 
 
287
    *num = 0;
 
288
 
 
289
    XDGACheckExtension (dpy, dinfo, NULL);
 
290
 
 
291
    LockDisplay(dpy);
 
292
    GetReq(XDGAQueryModes, req);
 
293
    req->reqType = dinfo->codes->major_opcode;
 
294
    req->dgaReqType = X_XDGAQueryModes;
 
295
    req->screen = screen;
 
296
 
 
297
    if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
298
        if(rep.length) {
 
299
           xXDGAModeInfo info;
 
300
           int i, size;
 
301
           char *offset;
 
302
 
 
303
           size = rep.length << 2;
 
304
           size -= rep.number * sz_xXDGAModeInfo; /* find text size */
 
305
           modes = (XDGAMode*)Xmalloc((rep.number * sizeof(XDGAMode)) + size);
 
306
           offset = (char*)(&modes[rep.number]); /* start of text */
 
307
 
 
308
 
 
309
           if(modes) {  
 
310
              for(i = 0; i < rep.number; i++) {
 
311
                _XRead(dpy, (char*)(&info), sz_xXDGAModeInfo);
 
312
 
 
313
                modes[i].num = info.num;
 
314
                modes[i].verticalRefresh = 
 
315
                        (float)info.vsync_num / (float)info.vsync_den;
 
316
                modes[i].flags = info.flags;
 
317
                modes[i].imageWidth = info.image_width;
 
318
                modes[i].imageHeight = info.image_height;
 
319
                modes[i].pixmapWidth = info.pixmap_width;
 
320
                modes[i].pixmapHeight = info.pixmap_height;
 
321
                modes[i].bytesPerScanline = info.bytes_per_scanline;
 
322
                modes[i].byteOrder = info.byte_order;
 
323
                modes[i].depth = info.depth;
 
324
                modes[i].bitsPerPixel = info.bpp;
 
325
                modes[i].redMask = info.red_mask;
 
326
                modes[i].greenMask = info.green_mask;
 
327
                modes[i].blueMask = info.blue_mask;
 
328
                modes[i].visualClass = info.visual_class;
 
329
                modes[i].viewportWidth = info.viewport_width;
 
330
                modes[i].viewportHeight = info.viewport_height;
 
331
                modes[i].xViewportStep = info.viewport_xstep;
 
332
                modes[i].yViewportStep = info.viewport_ystep;
 
333
                modes[i].maxViewportX = info.viewport_xmax;
 
334
                modes[i].maxViewportY = info.viewport_ymax;
 
335
                modes[i].viewportFlags = info.viewport_flags;
 
336
                modes[i].reserved1 = info.reserved1;
 
337
                modes[i].reserved2 = info.reserved2;    
 
338
 
 
339
                _XRead(dpy, offset, info.name_size);
 
340
                modes[i].name = offset;
 
341
                offset += info.name_size;
 
342
              }
 
343
              *num = rep.number;
 
344
           } else
 
345
                _XEatData(dpy, rep.length << 2);
 
346
        }
 
347
    }
 
348
 
 
349
    UnlockDisplay(dpy);
 
350
    SyncHandle();
 
351
 
 
352
    return modes;
 
353
}
 
354
 
 
355
 
 
356
XDGADevice * 
 
357
XDGASetMode(
 
358
    Display     *dpy,
 
359
    int         screen,
 
360
    int         mode
 
361
){
 
362
    XExtDisplayInfo *dinfo = xdga_find_display (dpy);
 
363
    xXDGASetModeReply rep;
 
364
    xXDGASetModeReq *req;
 
365
    XDGADevice *dev = NULL;
 
366
    Pixmap pid;
 
367
 
 
368
    XDGACheckExtension (dpy, dinfo, NULL);
 
369
 
 
370
    LockDisplay(dpy);
 
371
    GetReq(XDGASetMode, req);
 
372
    req->reqType = dinfo->codes->major_opcode;
 
373
    req->dgaReqType = X_XDGASetMode;
 
374
    req->screen = screen;
 
375
    req->mode = mode;
 
376
    req->pid = pid = XAllocID(dpy);
 
377
    
 
378
    if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 
379
        if(rep.length) {
 
380
           xXDGAModeInfo info;
 
381
           int size;
 
382
 
 
383
           size = rep.length << 2;
 
384
           size -= sz_xXDGAModeInfo; /* get text size */
 
385
 
 
386
           dev = (XDGADevice*)Xmalloc(sizeof(XDGADevice) + size);
 
387
            
 
388
           if(dev) {
 
389
                _XRead(dpy, (char*)(&info), sz_xXDGAModeInfo);
 
390
 
 
391
                dev->mode.num = info.num;
 
392
                dev->mode.verticalRefresh = 
 
393
                                (float)info.vsync_num / (float)info.vsync_den;
 
394
                dev->mode.flags = info.flags;
 
395
                dev->mode.imageWidth = info.image_width;
 
396
                dev->mode.imageHeight = info.image_height;
 
397
                dev->mode.pixmapWidth = info.pixmap_width;
 
398
                dev->mode.pixmapHeight = info.pixmap_height;
 
399
                dev->mode.bytesPerScanline = info.bytes_per_scanline;
 
400
                dev->mode.byteOrder = info.byte_order;
 
401
                dev->mode.depth = info.depth;
 
402
                dev->mode.bitsPerPixel = info.bpp;
 
403
                dev->mode.redMask = info.red_mask;
 
404
                dev->mode.greenMask = info.green_mask;
 
405
                dev->mode.blueMask = info.blue_mask;
 
406
                dev->mode.visualClass = info.visual_class;
 
407
                dev->mode.viewportWidth = info.viewport_width;
 
408
                dev->mode.viewportHeight = info.viewport_height;
 
409
                dev->mode.xViewportStep = info.viewport_xstep;
 
410
                dev->mode.yViewportStep = info.viewport_ystep;
 
411
                dev->mode.maxViewportX = info.viewport_xmax;
 
412
                dev->mode.maxViewportY = info.viewport_ymax;
 
413
                dev->mode.viewportFlags = info.viewport_flags;
 
414
                dev->mode.reserved1 = info.reserved1;
 
415
                dev->mode.reserved2 = info.reserved2;
 
416
 
 
417
                dev->mode.name = (char*)(&dev[1]);      
 
418
                _XRead(dpy, dev->mode.name, info.name_size);
 
419
 
 
420
                dev->pixmap = (rep.flags & XDGAPixmap) ? pid : 0;
 
421
                dev->data = XDGAGetMappedMemory(screen);
 
422
 
 
423
                if(dev->data)
 
424
                    dev->data += rep.offset;
 
425
           } 
 
426
           /* not sure what to do if the allocation fails */
 
427
        }
 
428
    }
 
429
 
 
430
    UnlockDisplay(dpy);
 
431
    SyncHandle();
 
432
 
 
433
    return dev;
 
434
}
 
435
 
 
436
 
 
437
void XDGASetViewport(
 
438
    Display     *dpy,
 
439
    int         screen,
 
440
    int         x,
 
441
    int         y,
 
442
    int         flags
 
443
){
 
444
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
445
    xXDGASetViewportReq *req;
 
446
 
 
447
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
448
 
 
449
    LockDisplay(dpy);
 
450
    GetReq(XDGASetViewport, req);
 
451
    req->reqType = info->codes->major_opcode;
 
452
    req->dgaReqType = X_XDGASetViewport;
 
453
    req->screen = screen;
 
454
    req->x = x;
 
455
    req->y = y;
 
456
    req->flags = flags;
 
457
    UnlockDisplay(dpy);
 
458
    SyncHandle();
 
459
}
 
460
 
 
461
 
 
462
void XDGAInstallColormap(
 
463
    Display     *dpy,
 
464
    int         screen,
 
465
    Colormap    cmap
 
466
){
 
467
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
468
    xXDGAInstallColormapReq *req;
 
469
 
 
470
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
471
 
 
472
    LockDisplay(dpy);
 
473
    GetReq(XDGAInstallColormap, req);
 
474
    req->reqType = info->codes->major_opcode;
 
475
    req->dgaReqType = X_XDGAInstallColormap;
 
476
    req->screen = screen;
 
477
    req->cmap = cmap;
 
478
    UnlockDisplay(dpy);
 
479
    SyncHandle();
 
480
}
 
481
 
 
482
void XDGASelectInput(
 
483
    Display     *dpy,
 
484
    int         screen,
 
485
    long        mask
 
486
){
 
487
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
488
    xXDGASelectInputReq *req;
 
489
 
 
490
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
491
 
 
492
    LockDisplay(dpy);
 
493
    GetReq(XDGASelectInput, req);
 
494
    req->reqType = info->codes->major_opcode;
 
495
    req->dgaReqType = X_XDGASelectInput;
 
496
    req->screen = screen;
 
497
    req->mask = mask;
 
498
    UnlockDisplay(dpy);
 
499
    SyncHandle();
 
500
}
 
501
 
 
502
void XDGAFillRectangle(
 
503
    Display     *dpy,
 
504
    int         screen,
 
505
    int         x,
 
506
    int         y,
 
507
    unsigned int        width,
 
508
    unsigned int        height,
 
509
    unsigned long       color
 
510
){
 
511
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
512
    xXDGAFillRectangleReq *req;
 
513
 
 
514
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
515
 
 
516
    LockDisplay(dpy);
 
517
    GetReq(XDGAFillRectangle, req);
 
518
    req->reqType = info->codes->major_opcode;
 
519
    req->dgaReqType = X_XDGAFillRectangle;
 
520
    req->screen = screen;
 
521
    req->x = x;
 
522
    req->y = y;
 
523
    req->width = width;
 
524
    req->height = height;
 
525
    req->color = color;
 
526
    UnlockDisplay(dpy);
 
527
    SyncHandle();
 
528
}
 
529
 
 
530
void XDGACopyArea(
 
531
    Display     *dpy,
 
532
    int         screen,
 
533
    int         srcx,
 
534
    int         srcy,
 
535
    unsigned int        width,
 
536
    unsigned int        height,
 
537
    int         dstx,
 
538
    int         dsty
 
539
){
 
540
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
541
    xXDGACopyAreaReq *req;
 
542
 
 
543
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
544
 
 
545
    LockDisplay(dpy);
 
546
    GetReq(XDGACopyArea, req);
 
547
    req->reqType = info->codes->major_opcode;
 
548
    req->dgaReqType = X_XDGACopyArea;
 
549
    req->screen = screen;
 
550
    req->srcx = srcx;
 
551
    req->srcy = srcy;
 
552
    req->width = width;
 
553
    req->height = height;
 
554
    req->dstx = dstx;
 
555
    req->dsty = dsty;
 
556
    UnlockDisplay(dpy);
 
557
    SyncHandle();
 
558
}
 
559
 
 
560
void XDGACopyTransparentArea(
 
561
    Display     *dpy,
 
562
    int         screen,
 
563
    int         srcx,
 
564
    int         srcy,
 
565
    unsigned int        width,
 
566
    unsigned int        height,
 
567
    int         dstx,
 
568
    int         dsty,
 
569
    unsigned long key
 
570
){
 
571
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
572
    xXDGACopyTransparentAreaReq *req;
 
573
 
 
574
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
575
 
 
576
    LockDisplay(dpy);
 
577
    GetReq(XDGACopyTransparentArea, req);
 
578
    req->reqType = info->codes->major_opcode;
 
579
    req->dgaReqType = X_XDGACopyTransparentArea;
 
580
    req->screen = screen;
 
581
    req->srcx = srcx;
 
582
    req->srcy = srcy;
 
583
    req->width = width;
 
584
    req->height = height;
 
585
    req->dstx = dstx;
 
586
    req->dsty = dsty;
 
587
    req->key = key;
 
588
    UnlockDisplay(dpy);
 
589
    SyncHandle();
 
590
}
 
591
 
 
592
 
 
593
int XDGAGetViewportStatus(
 
594
    Display *dpy,
 
595
    int screen 
 
596
){
 
597
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
598
    xXDGAGetViewportStatusReply rep;
 
599
    xXDGAGetViewportStatusReq *req;
 
600
    int status = 0;
 
601
 
 
602
    XDGACheckExtension (dpy, info, 0);
 
603
 
 
604
    LockDisplay(dpy);
 
605
    GetReq(XDGAGetViewportStatus, req);
 
606
    req->reqType = info->codes->major_opcode;
 
607
    req->dgaReqType = X_XDGAGetViewportStatus;
 
608
    req->screen = screen;
 
609
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse))
 
610
        status = rep.status;
 
611
    UnlockDisplay(dpy);
 
612
    SyncHandle();
 
613
    return status;
 
614
}
 
615
 
 
616
void XDGASync(
 
617
    Display *dpy,
 
618
    int screen 
 
619
){
 
620
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
621
    xXDGASyncReply rep;
 
622
    xXDGASyncReq *req;
 
623
 
 
624
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
625
 
 
626
    LockDisplay(dpy);
 
627
    GetReq(XDGASync, req);
 
628
    req->reqType = info->codes->major_opcode;
 
629
    req->dgaReqType = X_XDGASync;
 
630
    req->screen = screen;
 
631
    _XReply(dpy, (xReply *)&rep, 0, xFalse);
 
632
    UnlockDisplay(dpy);
 
633
    SyncHandle();
 
634
}
 
635
 
 
636
 
 
637
void XDGAChangePixmapMode(
 
638
    Display *dpy,
 
639
    int screen,
 
640
    int *x,
 
641
    int *y,
 
642
    int mode 
 
643
){
 
644
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
645
    xXDGAChangePixmapModeReq *req;
 
646
    xXDGAChangePixmapModeReply rep;
 
647
 
 
648
    XextSimpleCheckExtension (dpy, info, xdga_extension_name);
 
649
 
 
650
    LockDisplay(dpy);
 
651
    GetReq(XDGAChangePixmapMode, req);
 
652
    req->reqType = info->codes->major_opcode;
 
653
    req->dgaReqType = X_XDGAChangePixmapMode;
 
654
    req->screen = screen;
 
655
    req->x = *x;
 
656
    req->y = *y;
 
657
    req->flags = mode;
 
658
    _XReply(dpy, (xReply *)&rep, 0, xFalse);
 
659
    *x = rep.x;
 
660
    *y = rep.y;
 
661
    UnlockDisplay(dpy);
 
662
    SyncHandle();
 
663
}
 
664
 
 
665
Colormap XDGACreateColormap(
 
666
    Display *dpy,
 
667
    int screen,
 
668
    XDGADevice *dev,
 
669
    int alloc
 
670
){
 
671
    XExtDisplayInfo *info = xdga_find_display (dpy);
 
672
    xXDGACreateColormapReq *req;
 
673
    Colormap cid;
 
674
 
 
675
    XDGACheckExtension (dpy, info, -1);
 
676
 
 
677
    LockDisplay(dpy);
 
678
    GetReq(XDGACreateColormap, req);
 
679
    req->reqType = info->codes->major_opcode;
 
680
    req->dgaReqType = X_XDGACreateColormap;
 
681
    req->screen = screen;
 
682
    req->mode = dev->mode.num;
 
683
    req->alloc = alloc;
 
684
    cid = req->id = XAllocID(dpy);
 
685
    UnlockDisplay(dpy);
 
686
    SyncHandle();
 
687
 
 
688
    return cid;
 
689
}
 
690
 
 
691
 
 
692
void XDGAKeyEventToXKeyEvent(
 
693
    XDGAKeyEvent* dk, 
 
694
    XKeyEvent* xk
 
695
){
 
696
    xk->type = dk->type;
 
697
    xk->serial = dk->serial;
 
698
    xk->send_event = False;
 
699
    xk->display = dk->display;
 
700
    xk->window = RootWindow(dk->display, dk->screen);
 
701
    xk->root = xk->window;
 
702
    xk->subwindow = None;
 
703
    xk->time = dk->time;
 
704
    xk->x = xk->y = xk->x_root = xk->y_root = 0;
 
705
    xk->state = dk->state;
 
706
    xk->keycode = dk->keycode;
 
707
    xk->same_screen = True;
 
708
}
 
709
 
 
710
#include <X11/Xmd.h>
 
711
#include <X11/extensions/xf86dga.h>
 
712
#include <stdlib.h>
 
713
#include <stdio.h>
 
714
#include <fcntl.h>
 
715
#if defined(ISC) 
 
716
# define HAS_SVR3_MMAP
 
717
# include <sys/types.h>
 
718
# include <errno.h>
 
719
 
 
720
# include <sys/at_ansi.h>
 
721
# include <sys/kd.h>
 
722
 
 
723
# include <sys/sysmacros.h>
 
724
# include <sys/immu.h>
 
725
# include <sys/region.h>
 
726
 
 
727
# include <sys/mmap.h>
 
728
#else
 
729
# if defined(Lynx) && defined(NO_MMAP)
 
730
#  include <sys/types.h>
 
731
#  include <errno.h>
 
732
#  include <smem.h>
 
733
# else
 
734
#  if !defined(__UNIXOS2__)
 
735
#   include <sys/mman.h>
 
736
#  endif
 
737
# endif
 
738
#endif
 
739
#include <sys/wait.h>
 
740
#include <signal.h>
 
741
#include <unistd.h>
 
742
 
 
743
#if defined(SVR4) && !defined(sun) && !defined(SCO325)
 
744
#define DEV_MEM "/dev/pmem"
 
745
#elif defined(SVR4) && defined(sun)
 
746
#define DEV_MEM "/dev/xsvc"
 
747
#else
 
748
#define DEV_MEM "/dev/mem"
 
749
#endif
 
750
 
 
751
 
 
752
 
 
753
typedef struct _DGAMapRec{
 
754
  unsigned char *physical;
 
755
  unsigned char *virtual;
 
756
  CARD32 size;
 
757
  int fd;
 
758
  int screen;
 
759
  struct _DGAMapRec *next;
 
760
} DGAMapRec, *DGAMapPtr;
 
761
 
 
762
static Bool
 
763
DGAMapPhysical(int, char*, unsigned char*, CARD32, CARD32, CARD32, DGAMapPtr); 
 
764
static void DGAUnmapPhysical(DGAMapPtr);
 
765
 
 
766
static DGAMapPtr _Maps = NULL;
 
767
 
 
768
 
 
769
unsigned char*
 
770
XDGAGetMappedMemory(int screen)
 
771
{
 
772
    DGAMapPtr pMap = _Maps;
 
773
    unsigned char *pntr = NULL;
 
774
 
 
775
    while(pMap != NULL) {
 
776
        if(pMap->screen == screen) {
 
777
            pntr = pMap->virtual;
 
778
            break;
 
779
        }
 
780
        pMap = pMap->next;
 
781
    }
 
782
 
 
783
    return pntr;
 
784
}
 
785
 
 
786
Bool
 
787
XDGAMapFramebuffer(
 
788
   int screen,
 
789
   char *name,                  /* optional device name */
 
790
   unsigned char* base,         /* physical memory */
 
791
   CARD32 size,                 /* size */
 
792
   CARD32 offset,               /* optional offset */
 
793
   CARD32 extra                 /* optional extra data */
 
794
){
 
795
   DGAMapPtr pMap = _Maps;
 
796
   Bool result;
 
797
   
 
798
   /* is it already mapped ? */
 
799
   while(pMap != NULL) {
 
800
     if(pMap->screen == screen)
 
801
        return True;
 
802
     pMap = pMap->next;
 
803
   }
 
804
 
 
805
   if(extra & XDGANeedRoot) {
 
806
    /* we should probably check if we have root permissions and
 
807
       return False here */
 
808
 
 
809
   }
 
810
 
 
811
   pMap = (DGAMapPtr)Xmalloc(sizeof(DGAMapRec));
 
812
 
 
813
   result = DGAMapPhysical(screen, name, base, size, offset, extra, pMap);
 
814
 
 
815
   if(result) {
 
816
      pMap->next = _Maps;
 
817
      _Maps = pMap;
 
818
   } else 
 
819
      Xfree(pMap);
 
820
   
 
821
   return result;
 
822
}
 
823
 
 
824
void
 
825
XDGAUnmapFramebuffer(int screen)
 
826
{
 
827
   DGAMapPtr pMap = _Maps;
 
828
   DGAMapPtr pPrev = NULL;
 
829
 
 
830
   /* is it already mapped */
 
831
    while(pMap != NULL) {
 
832
        if(pMap->screen == screen)
 
833
            break;
 
834
        pPrev = pMap;
 
835
        pMap = pMap->next;
 
836
    }
 
837
 
 
838
    if(!pMap)
 
839
        return;
 
840
 
 
841
    DGAUnmapPhysical(pMap);
 
842
 
 
843
    if(!pPrev)
 
844
        _Maps = pMap->next;
 
845
    else
 
846
        pPrev->next = pMap->next;
 
847
 
 
848
    Xfree(pMap);
 
849
}
 
850
 
 
851
 
 
852
static Bool
 
853
DGAMapPhysical(
 
854
   int screen,
 
855
   char *name,                  /* optional device name */
 
856
   unsigned char* base,         /* physical memory */
 
857
   CARD32 size,                 /* size */
 
858
   CARD32 offset,               /* optional offset */
 
859
   CARD32 extra,                /* optional extra data */
 
860
   DGAMapPtr pMap
 
861
) {
 
862
#if defined(ISC) && defined(HAS_SVR3_MMAP)
 
863
    struct kd_memloc mloc;
 
864
#elif defined(__UNIXOS2__)
 
865
    APIRET rc;
 
866
    ULONG action;
 
867
    HFILE hfd;
 
868
#endif
 
869
  
 
870
    base += offset;
 
871
 
 
872
    pMap->screen = screen;
 
873
    pMap->physical = base;
 
874
    pMap->size = size;
 
875
 
 
876
#if defined(ISC) && defined(HAS_SVR3_MMAP)
 
877
    if ((pMap->fd = open("/dev/mmap", O_RDWR)) < 0)
 
878
        return False;
 
879
    mloc.vaddr = (char *)0;
 
880
    mloc.physaddr = (char *)base;
 
881
    mloc.length = size;
 
882
    mloc.ioflg=1;
 
883
 
 
884
    if ((pMap->virtual = (void *)ioctl(pMap->fd, MAP, &mloc)) == (void *)-1)
 
885
        return False;
 
886
#elif defined (__UNIXOS2__)
 
887
    /*
 
888
     * Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
 
889
     * Consecutive calling of this routine will make PMAP$ driver run out
 
890
     * of memory handles. Some umap/close mechanism should be provided
 
891
     */
 
892
 
 
893
    rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
 
894
                 OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
 
895
    if (rc != 0)
 
896
        return False;
 
897
    {
 
898
        struct map_ioctl {
 
899
                union {
 
900
                        ULONG phys;
 
901
                        void* user;
 
902
                } a;
 
903
                ULONG size;
 
904
        } pmap,dmap;
 
905
        ULONG plen,dlen;
 
906
#define XFREE86_PMAP    0x76
 
907
#define PMAP_MAP        0x44
 
908
 
 
909
        pmap.a.phys = base;
 
910
        pmap.size = size;
 
911
        rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
 
912
                         (PULONG)&pmap, sizeof(pmap), &plen,
 
913
                         (PULONG)&dmap, sizeof(dmap), &dlen);
 
914
        if (rc == 0) {
 
915
                pMap->virtual = dmap.a.user;
 
916
        }
 
917
   }
 
918
   if (rc != 0)
 
919
        return False;
 
920
#elif defined (Lynx) && defined(NO_MMAP)
 
921
    pMap->virtual = smem_create("XF86DGA", (char*)base, size, SM_READ|SM_WRITE);
 
922
#else
 
923
#ifndef MAP_FILE
 
924
#define MAP_FILE 0
 
925
#endif
 
926
    if (!name)
 
927
            name = DEV_MEM;
 
928
    if ((pMap->fd = open(name, O_RDWR)) < 0)
 
929
        return False;
 
930
    pMap->virtual = mmap(NULL, size, PROT_READ | PROT_WRITE, 
 
931
                        MAP_FILE | MAP_SHARED, pMap->fd, (off_t)base);
 
932
    if (pMap->virtual == (void *)-1)
 
933
        return False;
 
934
#endif
 
935
 
 
936
#if !defined(ISC) && !defined(HAS_SVR3_MMAP) \
 
937
        && !(defined(Lynx) && defined(NO_MMAP)) \
 
938
        && !defined(__UNIXOS2__)
 
939
    mprotect(pMap->virtual, size, PROT_READ | PROT_WRITE);
 
940
#endif
 
941
 
 
942
    return True;
 
943
}
 
944
 
 
945
 
 
946
 
 
947
static void
 
948
DGAUnmapPhysical(DGAMapPtr pMap)
 
949
{
 
950
#if !defined(ISC) && !defined(HAS_SVR3_MMAP) \
 
951
        && !(defined(Lynx) && defined(NO_MMAP)) \
 
952
        && !defined(__UNIXOS2__)
 
953
    mprotect(pMap->virtual,pMap->size, PROT_READ);
 
954
#elif defined(Lynx) && defined(NO_MMAP)
 
955
        /* XXX this doesn't allow enable after disable */
 
956
    smem_create(NULL, pMap->virtual, pMap->size, SM_DETACH);
 
957
    smem_remove("XF86DGA");
 
958
#endif
 
959
 
 
960
 
 
961
   /* We need to unmap and close too !!!!!!!!!!*/
 
962
}