diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA.c')
-rw-r--r-- | apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA.c | 721 |
1 files changed, 0 insertions, 721 deletions
diff --git a/apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA.c b/apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA.c deleted file mode 100644 index fc729f1257..0000000000 --- a/apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA.c +++ /dev/null | |||
@@ -1,721 +0,0 @@ | |||
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 | |||