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