Mercurial > sdl-ios-xcode

comparison src/video/Xext/Xxf86dga/XF86DGA2.c @ 1895:c121d94672cb

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