summaryrefslogtreecommitdiff
path: root/apps/plugins/sdl/src/video/Xext/Xxf86dga
diff options
context:
space:
mode:
Diffstat (limited to 'apps/plugins/sdl/src/video/Xext/Xxf86dga')
-rw-r--r--apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA.c721
-rw-r--r--apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA2.c993
2 files changed, 0 insertions, 1714 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
4Copyright (c) 1995 Jon Tombs
5Copyright (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
73extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);
74extern 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
85Bool 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
93Bool SDL_NAME(XF86DGAQueryVersion)(
94 Display* dpy,
95 int* majorVersion,
96 int* minorVersion
97){
98 return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);
99}
100
101Bool 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
137Bool 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
159Bool 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
191Bool 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
216Bool 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
245Bool 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
267Bool 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
289Bool 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
316Bool 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
388typedef 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
396typedef struct {
397 Display * display;
398 int screen;
399 MapPtr map;
400} ScrRec, *ScrPtr;
401
402static int mapFd = -1;
403static int numMaps = 0;
404static int numScrs = 0;
405static MapPtr *mapList = NULL;
406static ScrPtr *scrList = NULL;
407
408static MapPtr
409AddMap(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
425static ScrPtr
426AddScr(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
442static MapPtr
443FindMap(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
455static ScrPtr
456FindScr(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
468static void *
469MapPhysAddress(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
591int
592SDL_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
617Bool
618SDL_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
652static void
653XF86cleanup(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
671Bool
672SDL_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
deleted file mode 100644
index 11d4fddc6a..0000000000
--- a/apps/plugins/sdl/src/video/Xext/Xxf86dga/XF86DGA2.c
+++ /dev/null
@@ -1,993 +0,0 @@
1/* $XFree86: xc/lib/Xxf86dga/XF86DGA2.c,v 1.18 2001/08/17 13:27:51 dawes Exp $ */
2/*
3
4Copyright (c) 1995 Jon Tombs
5Copyright (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
40char *SDL_NAME(xdga_extension_name) = XF86DGANAME;
41
42static XExtensionInfo _xdga_info_data;
43static XExtensionInfo *xdga_info = &_xdga_info_data;
44
45
46Bool SDL_NAME(XDGAMapFramebuffer)(int, char *, unsigned char*, CARD32, CARD32, CARD32);
47void SDL_NAME(XDGAUnmapFramebuffer)(int);
48unsigned 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
59static int xdga_close_display(Display *dpy, XExtCodes *codes);
60static Bool xdga_wire_to_event(Display *dpy, XEvent *event, xEvent *wire_ev);
61static Status xdga_event_to_wire(Display *dpy, XEvent *event, xEvent *wire_ev);
62
63static 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
77static XEXT_GENERATE_CLOSE_DISPLAY (xdga_close_display, xdga_info)
78
79
80XEXT_GENERATE_FIND_DISPLAY (SDL_NAME(xdga_find_display), xdga_info,
81 "XFree86-DGA",
82 &xdga_extension_hooks,
83 0, NULL)
84
85
86static Status
87xdga_event_to_wire(
88 Display *dpy,
89 XEvent *event,
90 xEvent *wire_ev
91){
92 return True;
93}
94
95static Bool
96xdga_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
149Bool 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
166Bool 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
206Bool 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
225Bool 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
265void 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
287SDL_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
366SDL_NAME(XDGADevice) *
367SDL_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
447void 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
472void 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
492void 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
512void 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
540void 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
570void 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
603int 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
626void 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
647void 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
675Colormap 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
702void 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
762typedef 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
771static Bool
772DGAMapPhysical(int, char*, unsigned char*, CARD32, CARD32, CARD32, DGAMapPtr);
773static void DGAUnmapPhysical(DGAMapPtr);
774
775static DGAMapPtr _Maps = NULL;
776
777
778unsigned char*
779SDL_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
795Bool
796SDL_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
833void
834SDL_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
861static Bool
862DGAMapPhysical(
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
979static void
980DGAUnmapPhysical(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}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-30 19:31:22 +0000