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