Mercurial > sdl-ios-xcode

comparison src/video/Xext/Xxf86dga/XF86DGA.c @ 292:eadc0746dfaf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added SDL_LockRect() and SDL_UnlockRect() Incorporated XFree86 extension libraries into the source
author Sam Lantinga <slouken@libsdl.org>
date Tue, 05 Mar 2002 19:55:32 +0000
parents
children 045f186426e1
comparison
equal deleted inserted replaced
291:68a8a8237c09 292:eadc0746dfaf
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
60 #define NEED_EVENTS
61 #define NEED_REPLIES
62 #include <X11/Xlibint.h>
63 #include "xf86dga.h"
64 #include "xf86dgastr.h"
65 #include <X11/extensions/Xext.h>
66 #include "extutil.h"
67
68 extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);
69 extern char *SDL_NAME(xdga_extension_name);
70
71 #define XF86DGACheckExtension(dpy,i,val) \
72 XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)
73
74 /*****************************************************************************
75 * *
76 * public XFree86-DGA Extension routines *
77 * *
78 *****************************************************************************/
79
80 Bool SDL_NAME(XF86DGAQueryExtension) (
81 Display *dpy,
82 int *event_basep,
83 int *error_basep
84 ){
85 return SDL_NAME(XDGAQueryExtension)(dpy, event_basep, error_basep);
86 }
87
88 Bool SDL_NAME(XF86DGAQueryVersion)(
89 Display* dpy,
90 int* majorVersion,
91 int* minorVersion
92 ){
93 return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);
94 }
95
96 Bool SDL_NAME(XF86DGAGetVideoLL)(
97 Display* dpy,
98 int screen,
99 int *offset,
100 int *width,
101 int *bank_size,
102 int *ram_size
103 ){
104 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
105 xXF86DGAGetVideoLLReply rep;
106 xXF86DGAGetVideoLLReq *req;
107
108 XF86DGACheckExtension (dpy, info, False);
109
110 LockDisplay(dpy);
111 GetReq(XF86DGAGetVideoLL, req);
112 req->reqType = info->codes->major_opcode;
113 req->dgaReqType = X_XF86DGAGetVideoLL;
114 req->screen = screen;
115 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
116 UnlockDisplay(dpy);
117 SyncHandle();
118 return False;
119 }
120
121 *offset = /*(char *)*/rep.offset;
122 *width = rep.width;
123 *bank_size = rep.bank_size;
124 *ram_size = rep.ram_size;
125
126 UnlockDisplay(dpy);
127 SyncHandle();
128 return True;
129 }
130
131
132 Bool SDL_NAME(XF86DGADirectVideoLL)(
133 Display* dpy,
134 int screen,
135 int enable
136 ){
137 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
138 xXF86DGADirectVideoReq *req;
139
140 XF86DGACheckExtension (dpy, info, False);
141
142 LockDisplay(dpy);
143 GetReq(XF86DGADirectVideo, req);
144 req->reqType = info->codes->major_opcode;
145 req->dgaReqType = X_XF86DGADirectVideo;
146 req->screen = screen;
147 req->enable = enable;
148 UnlockDisplay(dpy);
149 SyncHandle();
150 XSync(dpy,False);
151 return True;
152 }
153
154 Bool SDL_NAME(XF86DGAGetViewPortSize)(
155 Display* dpy,
156 int screen,
157 int *width,
158 int *height
159 ){
160 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
161 xXF86DGAGetViewPortSizeReply rep;
162 xXF86DGAGetViewPortSizeReq *req;
163
164 XF86DGACheckExtension (dpy, info, False);
165
166 LockDisplay(dpy);
167 GetReq(XF86DGAGetViewPortSize, req);
168 req->reqType = info->codes->major_opcode;
169 req->dgaReqType = X_XF86DGAGetViewPortSize;
170 req->screen = screen;
171 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
172 UnlockDisplay(dpy);
173 SyncHandle();
174 return False;
175 }
176
177 *width = rep.width;
178 *height = rep.height;
179
180 UnlockDisplay(dpy);
181 SyncHandle();
182 return True;
183 }
184
185
186 Bool SDL_NAME(XF86DGASetViewPort)(
187 Display* dpy,
188 int screen,
189 int x,
190 int y
191 ){
192 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
193 xXF86DGASetViewPortReq *req;
194
195 XF86DGACheckExtension (dpy, info, False);
196
197 LockDisplay(dpy);
198 GetReq(XF86DGASetViewPort, req);
199 req->reqType = info->codes->major_opcode;
200 req->dgaReqType = X_XF86DGASetViewPort;
201 req->screen = screen;
202 req->x = x;
203 req->y = y;
204 UnlockDisplay(dpy);
205 SyncHandle();
206 XSync(dpy,False);
207 return True;
208 }
209
210
211 Bool SDL_NAME(XF86DGAGetVidPage)(
212 Display* dpy,
213 int screen,
214 int *vpage
215 ){
216 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
217 xXF86DGAGetVidPageReply rep;
218 xXF86DGAGetVidPageReq *req;
219
220 XF86DGACheckExtension (dpy, info, False);
221
222 LockDisplay(dpy);
223 GetReq(XF86DGAGetVidPage, req);
224 req->reqType = info->codes->major_opcode;
225 req->dgaReqType = X_XF86DGAGetVidPage;
226 req->screen = screen;
227 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
228 UnlockDisplay(dpy);
229 SyncHandle();
230 return False;
231 }
232
233 *vpage = rep.vpage;
234 UnlockDisplay(dpy);
235 SyncHandle();
236 return True;
237 }
238
239
240 Bool SDL_NAME(XF86DGASetVidPage)(
241 Display* dpy,
242 int screen,
243 int vpage
244 ){
245 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
246 xXF86DGASetVidPageReq *req;
247
248 XF86DGACheckExtension (dpy, info, False);
249
250 LockDisplay(dpy);
251 GetReq(XF86DGASetVidPage, req);
252 req->reqType = info->codes->major_opcode;
253 req->dgaReqType = X_XF86DGASetVidPage;
254 req->screen = screen;
255 req->vpage = vpage;
256 UnlockDisplay(dpy);
257 SyncHandle();
258 XSync(dpy,False);
259 return True;
260 }
261
262 Bool SDL_NAME(XF86DGAInstallColormap)(
263 Display* dpy,
264 int screen,
265 Colormap cmap
266 ){
267 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
268 xXF86DGAInstallColormapReq *req;
269
270 XF86DGACheckExtension (dpy, info, False);
271
272 LockDisplay(dpy);
273 GetReq(XF86DGAInstallColormap, req);
274 req->reqType = info->codes->major_opcode;
275 req->dgaReqType = X_XF86DGAInstallColormap;
276 req->screen = screen;
277 req->id = cmap;
278 UnlockDisplay(dpy);
279 SyncHandle();
280 XSync(dpy,False);
281 return True;
282 }
283
284 Bool SDL_NAME(XF86DGAQueryDirectVideo)(
285 Display *dpy,
286 int screen,
287 int *flags
288 ){
289 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
290 xXF86DGAQueryDirectVideoReply rep;
291 xXF86DGAQueryDirectVideoReq *req;
292
293 XF86DGACheckExtension (dpy, info, False);
294
295 LockDisplay(dpy);
296 GetReq(XF86DGAQueryDirectVideo, req);
297 req->reqType = info->codes->major_opcode;
298 req->dgaReqType = X_XF86DGAQueryDirectVideo;
299 req->screen = screen;
300 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
301 UnlockDisplay(dpy);
302 SyncHandle();
303 return False;
304 }
305 *flags = rep.flags;
306 UnlockDisplay(dpy);
307 SyncHandle();
308 return True;
309 }
310
311 Bool SDL_NAME(XF86DGAViewPortChanged)(
312 Display *dpy,
313 int screen,
314 int n
315 ){
316 XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
317 xXF86DGAViewPortChangedReply rep;
318 xXF86DGAViewPortChangedReq *req;
319
320 XF86DGACheckExtension (dpy, info, False);
321
322 LockDisplay(dpy);
323 GetReq(XF86DGAViewPortChanged, req);
324 req->reqType = info->codes->major_opcode;
325 req->dgaReqType = X_XF86DGAViewPortChanged;
326 req->screen = screen;
327 req->n = n;
328 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
329 UnlockDisplay(dpy);
330 SyncHandle();
331 return False;
332 }
333 UnlockDisplay(dpy);
334 SyncHandle();
335 return rep.result;
336 }
337
338
339
340 /* Helper functions */
341
342 #include <X11/Xmd.h>
343 #include <XFree86/extensions/xf86dga.h>
344 #include <stdlib.h>
345 #include <stdio.h>
346 #include <fcntl.h>
347 #if defined(ISC)
348 # define HAS_SVR3_MMAP
349 # include <sys/types.h>
350 # include <errno.h>
351
352 # include <sys/at_ansi.h>
353 # include <sys/kd.h>
354
355 # include <sys/sysmacros.h>
356 # include <sys/immu.h>
357 # include <sys/region.h>
358
359 # include <sys/mmap.h>
360 #else
361 # if !defined(Lynx)
362 # if !defined(__EMX__)
363 # include <sys/mman.h>
364 # endif
365 # else
366 # include <sys/types.h>
367 # include <errno.h>
368 # include <smem.h>
369 # endif
370 #endif
371 #include <sys/wait.h>
372 #include <signal.h>
373 #include <unistd.h>
374
375 #if defined(SVR4) && !defined(sun) && !defined(SCO325)
376 #define DEV_MEM "/dev/pmem"
377 #elif defined(SVR4) && defined(sun)
378 #define DEV_MEM "/dev/xsvc"
379 #else
380 #define DEV_MEM "/dev/mem"
381 #endif
382
383 typedef struct {
384 unsigned long physaddr; /* actual requested physical address */
385 unsigned long size; /* actual requested map size */
386 unsigned long delta; /* delta to account for page alignment */
387 void * vaddr; /* mapped address, without the delta */
388 int refcount; /* reference count */
389 } MapRec, *MapPtr;
390
391 typedef struct {
392 Display * display;
393 int screen;
394 MapPtr map;
395 } ScrRec, *ScrPtr;
396
397 static int mapFd = -1;
398 static int numMaps = 0;
399 static int numScrs = 0;
400 static MapPtr *mapList = NULL;
401 static ScrPtr *scrList = NULL;
402
403 static MapPtr
404 AddMap(void)
405 {
406 MapPtr *old;
407
408 old = mapList;
409 mapList = realloc(mapList, sizeof(MapPtr) * (numMaps + 1));
410 if (!mapList) {
411 mapList = old;
412 return NULL;
413 }
414 mapList[numMaps] = malloc(sizeof(MapRec));
415 if (!mapList[numMaps])
416 return NULL;
417 return mapList[numMaps++];
418 }
419
420 static ScrPtr
421 AddScr(void)
422 {
423 ScrPtr *old;
424
425 old = scrList;
426 scrList = realloc(scrList, sizeof(ScrPtr) * (numScrs + 1));
427 if (!scrList) {
428 scrList = old;
429 return NULL;
430 }
431 scrList[numScrs] = malloc(sizeof(ScrRec));
432 if (!scrList[numScrs])
433 return NULL;
434 return scrList[numScrs++];
435 }
436
437 static MapPtr
438 FindMap(unsigned long address, unsigned long size)
439 {
440 int i;
441
442 for (i = 0; i < numMaps; i++) {
443 if (mapList[i]->physaddr == address &&
444 mapList[i]->size == size)
445 return mapList[i];
446 }
447 return NULL;
448 }
449
450 static ScrPtr
451 FindScr(Display *display, int screen)
452 {
453 int i;
454
455 for (i = 0; i < numScrs; i++) {
456 if (scrList[i]->display == display &&
457 scrList[i]->screen == screen)
458 return scrList[i];
459 }
460 return NULL;
461 }
462
463 static void *
464 MapPhysAddress(unsigned long address, unsigned long size)
465 {
466 unsigned long offset, delta;
467 int pagesize = -1;
468 void *vaddr;
469 MapPtr mp;
470 #if defined(ISC) && defined(HAS_SVR3_MMAP)
471 struct kd_memloc mloc;
472 #elif defined(__EMX__)
473 APIRET rc;
474 ULONG action;
475 HFILE hfd;
476 #endif
477
478 if ((mp = FindMap(address, size))) {
479 mp->refcount++;
480 return (void *)((unsigned long)mp->vaddr + mp->delta);
481 }
482
483 #if defined(_SC_PAGESIZE) && defined(HAS_SC_PAGESIZE)
484 pagesize = sysconf(_SC_PAGESIZE);
485 #endif
486 #ifdef _SC_PAGE_SIZE
487 if (pagesize == -1)
488 pagesize = sysconf(_SC_PAGE_SIZE);
489 #endif
490 #ifdef HAS_GETPAGESIZE
491 if (pagesize == -1)
492 pagesize = getpagesize();
493 #endif
494 #ifdef PAGE_SIZE
495 if (pagesize == -1)
496 pagesize = PAGE_SIZE;
497 #endif
498 if (pagesize == -1)
499 pagesize = 4096;
500
501 delta = address % pagesize;
502 offset = address - delta;
503
504 #if defined(ISC) && defined(HAS_SVR3_MMAP)
505 if (mapFd < 0) {
506 if ((mapFd = open("/dev/mmap", O_RDWR)) < 0)
507 return NULL;
508 }
509 mloc.vaddr = (char *)0;
510 mloc.physaddr = (char *)offset;
511 mloc.length = size + delta;
512 mloc.ioflg=1;
513
514 if ((vaddr = (void *)ioctl(mapFd, MAP, &mloc)) == (void *)-1)
515 return NULL;
516 #elif defined (__EMX__)
517 /*
518 * Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
519 * Consecutive calling of this routine will make PMAP$ driver run out
520 * of memory handles. Some umap/close mechanism should be provided
521 */
522
523 rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
524 OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
525 if (rc != 0)
526 return NULL;
527 {
528 struct map_ioctl {
529 union {
530 ULONG phys;
531 void* user;
532 } a;
533 ULONG size;
534 } pmap,dmap;
535 ULONG plen,dlen;
536 #define XFREE86_PMAP 0x76
537 #define PMAP_MAP 0x44
538
539 pmap.a.phys = offset;
540 pmap.size = size + delta;
541 rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
542 (PULONG)&pmap, sizeof(pmap), &plen,
543 (PULONG)&dmap, sizeof(dmap), &dlen);
544 if (rc == 0) {
545 vaddr = dmap.a.user;
546 }
547 }
548 if (rc != 0)
549 return NULL;
550 #elif defined (Lynx)
551 vaddr = (void *)smem_create("XF86DGA", (char *)offset,
552 size + delta, SM_READ|SM_WRITE);
553 #else
554 #ifndef MAP_FILE
555 #define MAP_FILE 0
556 #endif
557 if (mapFd < 0) {
558 if ((mapFd = open(DEV_MEM, O_RDWR)) < 0)
559 return NULL;
560 }
561 vaddr = (void *)mmap(NULL, size + delta, PROT_READ | PROT_WRITE,
562 MAP_FILE | MAP_SHARED, mapFd, (off_t)offset);
563 if (vaddr == (void *)-1)
564 return NULL;
565 #endif
566
567 if (!vaddr) {
568 if (!(mp = AddMap()))
569 return NULL;
570 mp->physaddr = address;
571 mp->size = size;
572 mp->delta = delta;
573 mp->vaddr = vaddr;
574 mp->refcount = 1;
575 }
576 return (void *)((unsigned long)vaddr + delta);
577 }
578
579 /*
580 * Still need to find a clean way of detecting the death of a DGA app
581 * and returning things to normal - Jon
582 * This is here to help debugging without rebooting... Also C-A-BS
583 * should restore text mode.
584 */
585
586 int
587 SDL_NAME(XF86DGAForkApp)(int screen)
588 {
589 pid_t pid;
590 int status;
591 int i;
592
593 /* fork the app, parent hangs around to clean up */
594 if ((pid = fork()) > 0) {
595 ScrPtr sp;
596
597 waitpid(pid, &status, 0);
598 for (i = 0; i < numScrs; i++) {
599 sp = scrList[i];
600 SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0);
601 XSync(sp->display, False);
602 }
603 if (WIFEXITED(status))
604 _exit(0);
605 else
606 _exit(-1);
607 }
608 return pid;
609 }
610
611
612 Bool
613 SDL_NAME(XF86DGADirectVideo)(
614 Display *dis,
615 int screen,
616 int enable
617 ){
618 ScrPtr sp;
619 MapPtr mp = NULL;
620
621 if ((sp = FindScr(dis, screen)))
622 mp = sp->map;
623
624 if (enable & XF86DGADirectGraphics) {
625 #if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
626 && !defined(__EMX__)
627 if (mp && mp->vaddr)
628 mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ | PROT_WRITE);
629 #endif
630 } else {
631 #if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
632 && !defined(__EMX__)
633 if (mp && mp->vaddr)
634 mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ);
635 #elif defined(Lynx)
636 /* XXX this doesn't allow enable after disable */
637 smem_create(NULL, mp->vaddr, mp->size + mp->delta, SM_DETACH);
638 smem_remove("XF86DGA");
639 #endif
640 }
641
642 SDL_NAME(XF86DGADirectVideoLL)(dis, screen, enable);
643 return 1;
644 }
645
646
647 static void
648 XF86cleanup(int sig)
649 {
650 ScrPtr sp;
651 int i;
652 static char beenhere = 0;
653
654 if (beenhere)
655 _exit(3);
656 beenhere = 1;
657
658 for (i = 0; i < numScrs; i++) {
659 sp = scrList[i];
660 SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0);
661 XSync(sp->display, False);
662 }
663 _exit(3);
664 }
665
666 Bool
667 SDL_NAME(XF86DGAGetVideo)(
668 Display *dis,
669 int screen,
670 char **addr,
671 int *width,
672 int *bank,
673 int *ram
674 ){
675 /*unsigned long*/ int offset;
676 static int beenHere = 0;
677 ScrPtr sp;
678 MapPtr mp;
679
680 if (!(sp = FindScr(dis, screen))) {
681 if (!(sp = AddScr())) {
682 fprintf(stderr, "XF86DGAGetVideo: malloc failure\n");
683 exit(-2);
684 }
685 sp->display = dis;
686 sp->screen = screen;
687 sp->map = NULL;
688 }
689
690 SDL_NAME(XF86DGAGetVideoLL)(dis, screen , &offset, width, bank, ram);
691
692 *addr = MapPhysAddress(offset, *bank);
693 if (*addr == NULL) {
694 fprintf(stderr, "XF86DGAGetVideo: failed to map video memory (%s)\n",
695 strerror(errno));
696 exit(-2);
697 }
698
699 if ((mp = FindMap(offset, *bank)))
700 sp->map = mp;
701
702 if (!beenHere) {
703 beenHere = 1;
704 atexit((void(*)(void))XF86cleanup);
705 /* one shot XF86cleanup attempts */
706 signal(SIGSEGV, XF86cleanup);
707 #ifdef SIGBUS
708 signal(SIGBUS, XF86cleanup);
709 #endif
710 signal(SIGHUP, XF86cleanup);
711 signal(SIGFPE, XF86cleanup);
712 }
713
714 return 1;
715 }
716