diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/fbcon')
21 files changed, 0 insertions, 6038 deletions
diff --git a/apps/plugins/sdl/src/video/fbcon/3dfx_mmio.h b/apps/plugins/sdl/src/video/fbcon/3dfx_mmio.h deleted file mode 100644 index b641454809..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/3dfx_mmio.h +++ /dev/null | |||
@@ -1,56 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* 3Dfx register definitions */ | ||
25 | |||
26 | #include "3dfx_regs.h" | ||
27 | |||
28 | /* 3Dfx control macros */ | ||
29 | |||
30 | #define tdfx_in8(reg) *(volatile Uint8 *)(mapped_io + (reg)) | ||
31 | #define tdfx_in32(reg) *(volatile Uint32 *)(mapped_io + (reg)) | ||
32 | |||
33 | #define tdfx_out8(reg,v) *(volatile Uint8 *)(mapped_io + (reg)) = v; | ||
34 | #define tdfx_out32(reg,v) *(volatile Uint32 *)(mapped_io + (reg)) = v; | ||
35 | |||
36 | |||
37 | /* Wait for fifo space */ | ||
38 | #define tdfx_wait(space) \ | ||
39 | { \ | ||
40 | while ( (tdfx_in8(TDFX_STATUS) & 0x1F) < space ) \ | ||
41 | ; \ | ||
42 | } | ||
43 | |||
44 | |||
45 | /* Wait for idle accelerator */ | ||
46 | #define tdfx_waitidle() \ | ||
47 | { \ | ||
48 | int i = 0; \ | ||
49 | \ | ||
50 | tdfx_wait(1); \ | ||
51 | tdfx_out32(COMMAND_3D, COMMAND_3D_NOP); \ | ||
52 | do { \ | ||
53 | i = (tdfx_in32(TDFX_STATUS) & STATUS_BUSY) ? 0 : i + 1; \ | ||
54 | } while ( i != 3 ); \ | ||
55 | } | ||
56 | |||
diff --git a/apps/plugins/sdl/src/video/fbcon/3dfx_regs.h b/apps/plugins/sdl/src/video/fbcon/3dfx_regs.h deleted file mode 100644 index e86f727b30..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/3dfx_regs.h +++ /dev/null | |||
@@ -1,83 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #ifndef _3DFX_REGS_H | ||
25 | #define _3DFX_REGS_H | ||
26 | |||
27 | /* This information comes from the public 3Dfx specs for the Voodoo 3000 */ | ||
28 | |||
29 | /* mapped_io register offsets */ | ||
30 | #define TDFX_STATUS 0x00 | ||
31 | |||
32 | #define INTCTRL (0x00100000 + 0x04) | ||
33 | #define CLIP0MIN (0x00100000 + 0x08) | ||
34 | #define CLIP0MAX (0x00100000 + 0x0c) | ||
35 | #define DSTBASE (0x00100000 + 0x10) | ||
36 | #define DSTFORMAT (0x00100000 + 0x14) | ||
37 | #define SRCCOLORKEYMIN (0x00100000 + 0x18) | ||
38 | #define SRCCOLORKEYMAX (0x00100000 + 0x1c) | ||
39 | #define DSTCOLORKEYMIN (0x00100000 + 0x20) | ||
40 | #define DSTCOLORKEYMAX (0x00100000 + 0x24) | ||
41 | #define BRESERROR0 (0x00100000 + 0x28) | ||
42 | #define BRESERROR1 (0x00100000 + 0x2c) | ||
43 | #define ROP_2D (0x00100000 + 0x30) | ||
44 | #define SRCBASE (0x00100000 + 0x34) | ||
45 | #define COMMANDEXTRA_2D (0x00100000 + 0x38) | ||
46 | #define PATTERN0 (0x00100000 + 0x44) | ||
47 | #define PATTERN1 (0x00100000 + 0x48) | ||
48 | #define CLIP1MIN (0x00100000 + 0x4c) | ||
49 | #define CLIP1MAX (0x00100000 + 0x50) | ||
50 | #define SRCFORMAT (0x00100000 + 0x54) | ||
51 | #define SRCSIZE (0x00100000 + 0x58) | ||
52 | #define SRCXY (0x00100000 + 0x5c) | ||
53 | #define COLORBACK (0x00100000 + 0x60) | ||
54 | #define COLORFORE (0x00100000 + 0x64) | ||
55 | #define DSTSIZE (0x00100000 + 0x68) | ||
56 | #define DSTXY (0x00100000 + 0x6c) | ||
57 | #define COMMAND_2D (0x00100000 + 0x70) | ||
58 | #define LAUNCH_2D (0x00100000 + 0x80) | ||
59 | #define PATTERNBASE (0x00100000 + 0x100) | ||
60 | |||
61 | #define COMMAND_3D (0x00200000 + 0x120) | ||
62 | |||
63 | /* register bitfields (not all, only as needed) */ | ||
64 | |||
65 | #define BIT(x) (1UL << (x)) | ||
66 | |||
67 | #define COMMAND_2D_BITBLT 0x01 | ||
68 | #define COMMAND_2D_FILLRECT 0x05 | ||
69 | #define COMMAND_2D_LINE 0x06 | ||
70 | #define COMMAND_2D_POLYGON_FILL 0x08 | ||
71 | #define COMMAND_2D_INITIATE BIT(8) | ||
72 | #define COMMAND_2D_REVERSELINE BIT(9) | ||
73 | #define COMMAND_2D_STIPPLELINE BIT(12) | ||
74 | #define COMMAND_2D_MONOCHROME_PATT BIT(13) | ||
75 | #define COMMAND_2D_MONOCHROME_TRANSP BIT(16) | ||
76 | |||
77 | #define COMMAND_3D_NOP 0x00 | ||
78 | |||
79 | #define STATUS_RETRACE BIT(6) | ||
80 | #define STATUS_BUSY BIT(9) | ||
81 | |||
82 | #endif /* _3DFX_REGS_H */ | ||
83 | |||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fb3dfx.c b/apps/plugins/sdl/src/video/fbcon/SDL_fb3dfx.c deleted file mode 100644 index eb083b85ab..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fb3dfx.c +++ /dev/null | |||
@@ -1,215 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_video.h" | ||
25 | #include "../SDL_blit.h" | ||
26 | #include "SDL_fb3dfx.h" | ||
27 | #include "3dfx_mmio.h" | ||
28 | |||
29 | |||
30 | /* Wait for vertical retrace */ | ||
31 | static void WaitVBL(_THIS) | ||
32 | { | ||
33 | /* find start of retrace */ | ||
34 | tdfx_waitidle(); | ||
35 | while( (tdfx_in32(TDFX_STATUS) & STATUS_RETRACE) == STATUS_RETRACE ) | ||
36 | ; | ||
37 | /* wait until we're past the start */ | ||
38 | while( (tdfx_in32(TDFX_STATUS) & STATUS_RETRACE) == 0 ) | ||
39 | ; | ||
40 | } | ||
41 | static void WaitIdle(_THIS) | ||
42 | { | ||
43 | tdfx_waitidle(); | ||
44 | } | ||
45 | |||
46 | /* Sets video mem colorkey and accelerated blit function */ | ||
47 | static int SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) | ||
48 | { | ||
49 | return(0); | ||
50 | } | ||
51 | |||
52 | static int FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color) | ||
53 | { | ||
54 | int bpp; | ||
55 | Uint32 dst_base; | ||
56 | Uint32 format; | ||
57 | int dstX, dstY; | ||
58 | |||
59 | /* Don't blit to the display surface when switched away */ | ||
60 | if ( switched_away ) { | ||
61 | return -2; /* no hardware access */ | ||
62 | } | ||
63 | if ( dst == this->screen ) { | ||
64 | SDL_mutexP(hw_lock); | ||
65 | } | ||
66 | |||
67 | /* Set the destination pixel format */ | ||
68 | dst_base = ((char *)dst->pixels - mapped_mem); | ||
69 | bpp = dst->format->BitsPerPixel; | ||
70 | format = dst->pitch | ((bpp+((bpp==8) ? 0 : 8)) << 13); | ||
71 | |||
72 | /* Calculate source and destination base coordinates */ | ||
73 | dstX = rect->x; | ||
74 | dstY = rect->y; | ||
75 | |||
76 | /* Execute the fill command */ | ||
77 | tdfx_wait(6); | ||
78 | tdfx_out32(DSTBASE, dst_base); | ||
79 | tdfx_out32(DSTFORMAT, format); | ||
80 | tdfx_out32(COLORFORE, color); | ||
81 | tdfx_out32(COMMAND_2D, COMMAND_2D_FILLRECT); | ||
82 | tdfx_out32(DSTSIZE, rect->w | (rect->h << 16)); | ||
83 | tdfx_out32(LAUNCH_2D, dstX | (dstY << 16)); | ||
84 | |||
85 | FB_AddBusySurface(dst); | ||
86 | |||
87 | if ( dst == this->screen ) { | ||
88 | SDL_mutexV(hw_lock); | ||
89 | } | ||
90 | return(0); | ||
91 | } | ||
92 | |||
93 | static int HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | ||
94 | SDL_Surface *dst, SDL_Rect *dstrect) | ||
95 | { | ||
96 | SDL_VideoDevice *this = current_video; | ||
97 | int bpp; | ||
98 | Uint32 src_format; | ||
99 | Uint32 src_base; | ||
100 | Uint32 dst_base; | ||
101 | int srcX, srcY; | ||
102 | int dstX, dstY; | ||
103 | Uint32 blitop; | ||
104 | Uint32 use_colorkey; | ||
105 | |||
106 | /* Don't blit to the display surface when switched away */ | ||
107 | if ( switched_away ) { | ||
108 | return -2; /* no hardware access */ | ||
109 | } | ||
110 | if ( dst == this->screen ) { | ||
111 | SDL_mutexP(hw_lock); | ||
112 | } | ||
113 | |||
114 | /* Set the source and destination pixel format */ | ||
115 | src_base = ((char *)src->pixels - mapped_mem); | ||
116 | bpp = src->format->BitsPerPixel; | ||
117 | src_format = src->pitch | ((bpp+((bpp==8) ? 0 : 8)) << 13); | ||
118 | dst_base = ((char *)dst->pixels - mapped_mem); | ||
119 | bpp = dst->format->BitsPerPixel; | ||
120 | |||
121 | srcX = srcrect->x; | ||
122 | srcY = srcrect->y; | ||
123 | dstX = dstrect->x; | ||
124 | dstY = dstrect->y; | ||
125 | |||
126 | /* Assemble the blit operation */ | ||
127 | blitop = COMMAND_2D_BITBLT | (0xCC << 24); | ||
128 | if ( srcX <= dstX ) { | ||
129 | blitop |= BIT(14); | ||
130 | srcX += (dstrect->w - 1); | ||
131 | dstX += (dstrect->w - 1); | ||
132 | } | ||
133 | if ( srcY <= dstY ) { | ||
134 | blitop |= BIT(15); | ||
135 | srcY += (dstrect->h - 1); | ||
136 | dstY += (dstrect->h - 1); | ||
137 | } | ||
138 | |||
139 | /* Perform the blit! */ | ||
140 | if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | ||
141 | tdfx_wait(3); | ||
142 | tdfx_out32(SRCCOLORKEYMIN, src->format->colorkey); | ||
143 | tdfx_out32(SRCCOLORKEYMAX, src->format->colorkey); | ||
144 | tdfx_out32(ROP_2D, 0xAA00); | ||
145 | use_colorkey = 1; | ||
146 | } else { | ||
147 | use_colorkey = 0; | ||
148 | } | ||
149 | tdfx_wait(9); | ||
150 | tdfx_out32(SRCBASE, (Uint32)src_base); | ||
151 | tdfx_out32(SRCFORMAT, src_format); | ||
152 | tdfx_out32(DSTBASE, (Uint32)dst_base); | ||
153 | tdfx_out32(DSTFORMAT, src_format); | ||
154 | tdfx_out32(COMMAND_2D, blitop); | ||
155 | tdfx_out32(COMMANDEXTRA_2D, use_colorkey); | ||
156 | tdfx_out32(DSTSIZE, dstrect->w | (dstrect->h << 16)); | ||
157 | tdfx_out32(DSTXY, dstX | (dstY << 16)); | ||
158 | tdfx_out32(LAUNCH_2D, srcX | (srcY << 16)); | ||
159 | |||
160 | FB_AddBusySurface(src); | ||
161 | FB_AddBusySurface(dst); | ||
162 | |||
163 | if ( dst == this->screen ) { | ||
164 | SDL_mutexV(hw_lock); | ||
165 | } | ||
166 | return(0); | ||
167 | } | ||
168 | |||
169 | static int CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst) | ||
170 | { | ||
171 | int accelerated; | ||
172 | |||
173 | /* Set initial acceleration on */ | ||
174 | src->flags |= SDL_HWACCEL; | ||
175 | |||
176 | /* Set the surface attributes */ | ||
177 | if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { | ||
178 | if ( ! this->info.blit_hw_A ) { | ||
179 | src->flags &= ~SDL_HWACCEL; | ||
180 | } | ||
181 | } | ||
182 | if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | ||
183 | if ( ! this->info.blit_hw_CC ) { | ||
184 | src->flags &= ~SDL_HWACCEL; | ||
185 | } | ||
186 | } | ||
187 | |||
188 | /* Check to see if final surface blit is accelerated */ | ||
189 | accelerated = !!(src->flags & SDL_HWACCEL); | ||
190 | if ( accelerated ) { | ||
191 | src->map->hw_blit = HWAccelBlit; | ||
192 | } | ||
193 | return(accelerated); | ||
194 | } | ||
195 | |||
196 | void FB_3DfxAccel(_THIS, __u32 card) | ||
197 | { | ||
198 | /* We have hardware accelerated surface functions */ | ||
199 | this->CheckHWBlit = CheckHWBlit; | ||
200 | wait_vbl = WaitVBL; | ||
201 | wait_idle = WaitIdle; | ||
202 | |||
203 | /* Reset the 3Dfx controller */ | ||
204 | tdfx_out32(BRESERROR0, 0); | ||
205 | tdfx_out32(BRESERROR1, 0); | ||
206 | |||
207 | /* The 3Dfx has an accelerated color fill */ | ||
208 | this->info.blit_fill = 1; | ||
209 | this->FillHWRect = FillHWRect; | ||
210 | |||
211 | /* The 3Dfx has accelerated normal and colorkey blits */ | ||
212 | this->info.blit_hw = 1; | ||
213 | this->info.blit_hw_CC = 1; | ||
214 | this->SetHWColorKey = SetHWColorKey; | ||
215 | } | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fb3dfx.h b/apps/plugins/sdl/src/video/fbcon/SDL_fb3dfx.h deleted file mode 100644 index 4a59de9d80..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fb3dfx.h +++ /dev/null | |||
@@ -1,29 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* 3Dfx hardware acceleration for the SDL framebuffer console driver */ | ||
25 | |||
26 | #include "SDL_fbvideo.h" | ||
27 | |||
28 | /* Set up the driver for 3Dfx acceleration */ | ||
29 | extern void FB_3DfxAccel(_THIS, __u32 card); | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbelo.c b/apps/plugins/sdl/src/video/fbcon/SDL_fbelo.c deleted file mode 100644 index 63dff87ce6..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbelo.c +++ /dev/null | |||
@@ -1,442 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include <unistd.h> | ||
25 | #include <sys/time.h> | ||
26 | #include <ctype.h> | ||
27 | |||
28 | #include "SDL_stdinc.h" | ||
29 | #include "SDL_fbvideo.h" | ||
30 | #include "SDL_fbelo.h" | ||
31 | |||
32 | /* | ||
33 | calibration default values | ||
34 | values are read from the following environment variables: | ||
35 | |||
36 | SDL_ELO_MIN_X | ||
37 | SDL_ELO_MAX_X | ||
38 | SDL_ELO_MIN_Y | ||
39 | SDL_ELO_MAX_Y | ||
40 | */ | ||
41 | |||
42 | static int ELO_MIN_X = 400; | ||
43 | static int ELO_MAX_X = 3670; | ||
44 | static int ELO_MIN_Y = 500; | ||
45 | static int ELO_MAX_Y = 3540; | ||
46 | |||
47 | #define ELO_SNAP_SIZE 6 | ||
48 | #define ELO_TOUCH_BYTE 'T' | ||
49 | #define ELO_ID 'I' | ||
50 | #define ELO_MODE 'M' | ||
51 | #define ELO_PARAMETER 'P' | ||
52 | #define ELO_REPORT 'B' | ||
53 | #define ELO_ACK 'A' | ||
54 | |||
55 | #define ELO_INIT_CHECKSUM 0xAA | ||
56 | |||
57 | #define ELO_BTN_PRESS 0x01 | ||
58 | #define ELO_STREAM 0x02 | ||
59 | #define ELO_BTN_RELEASE 0x04 | ||
60 | |||
61 | #define ELO_TOUCH_MODE 0x01 | ||
62 | #define ELO_STREAM_MODE 0x02 | ||
63 | #define ELO_UNTOUCH_MODE 0x04 | ||
64 | #define ELO_RANGE_CHECK_MODE 0x40 | ||
65 | #define ELO_TRIM_MODE 0x02 | ||
66 | #define ELO_CALIB_MODE 0x04 | ||
67 | #define ELO_SCALING_MODE 0x08 | ||
68 | #define ELO_TRACKING_MODE 0x40 | ||
69 | |||
70 | #define ELO_SERIAL_MASK 0xF8 | ||
71 | |||
72 | #define ELO_SERIAL_IO '0' | ||
73 | |||
74 | #define ELO_MAX_TRIALS 3 | ||
75 | #define ELO_MAX_WAIT 100000 | ||
76 | #define ELO_UNTOUCH_DELAY 5 | ||
77 | #define ELO_REPORT_DELAY 1 | ||
78 | |||
79 | /* eloParsePacket | ||
80 | */ | ||
81 | int eloParsePacket(unsigned char* mousebuf, int* dx, int* dy, int* button_state) { | ||
82 | static int elo_button = 0; | ||
83 | static int last_x = 0; | ||
84 | static int last_y = 0; | ||
85 | int x,y; | ||
86 | |||
87 | /* Check if we have a touch packet */ | ||
88 | if (mousebuf[1] != ELO_TOUCH_BYTE) { | ||
89 | return 0; | ||
90 | } | ||
91 | |||
92 | x = ((mousebuf[4] << 8) | mousebuf[3]); | ||
93 | y = ((mousebuf[6] << 8) | mousebuf[5]); | ||
94 | |||
95 | if((SDL_abs(x - last_x) > ELO_SNAP_SIZE) || (SDL_abs(y - last_y) > ELO_SNAP_SIZE)) { | ||
96 | *dx = ((mousebuf[4] << 8) | mousebuf[3]); | ||
97 | *dy = ((mousebuf[6] << 8) | mousebuf[5]); | ||
98 | } | ||
99 | else { | ||
100 | *dx = last_x; | ||
101 | *dy = last_y; | ||
102 | } | ||
103 | |||
104 | last_x = *dx; | ||
105 | last_y = *dy; | ||
106 | |||
107 | if ( (mousebuf[2] & 0x07) == ELO_BTN_PRESS ) { | ||
108 | elo_button = 1; | ||
109 | } | ||
110 | if ( (mousebuf[2] & 0x07) == ELO_BTN_RELEASE ) { | ||
111 | elo_button = 0; | ||
112 | } | ||
113 | |||
114 | *button_state = elo_button; | ||
115 | return 1; | ||
116 | } | ||
117 | |||
118 | /* Convert the raw coordinates from the ELO controller | ||
119 | to a screen position. | ||
120 | */ | ||
121 | void eloConvertXY(_THIS, int *dx, int *dy) { | ||
122 | int input_x = *dx; | ||
123 | int input_y = *dy; | ||
124 | int width = ELO_MAX_X - ELO_MIN_X; | ||
125 | int height = ELO_MAX_Y - ELO_MIN_Y; | ||
126 | |||
127 | *dx = ((int)cache_vinfo.xres - ((int)cache_vinfo.xres * (input_x - ELO_MIN_X)) / width); | ||
128 | *dy = (cache_vinfo.yres * (input_y - ELO_MIN_Y)) / height; | ||
129 | } | ||
130 | |||
131 | |||
132 | /* eloGetPacket | ||
133 | */ | ||
134 | int eloGetPacket(unsigned char* buffer, int* buffer_p, int* checksum, int fd) { | ||
135 | int num_bytes; | ||
136 | int ok; | ||
137 | |||
138 | if(fd == 0) { | ||
139 | num_bytes = ELO_PACKET_SIZE; | ||
140 | } | ||
141 | else { | ||
142 | num_bytes = read(fd, | ||
143 | (char *) (buffer + *buffer_p), | ||
144 | ELO_PACKET_SIZE - *buffer_p); | ||
145 | } | ||
146 | |||
147 | if (num_bytes < 0) { | ||
148 | #ifdef DEBUG_MOUSE | ||
149 | fprintf(stderr, "System error while reading from Elographics touchscreen.\n"); | ||
150 | #endif | ||
151 | return 0; | ||
152 | } | ||
153 | |||
154 | while (num_bytes) { | ||
155 | if ((*buffer_p == 0) && (buffer[0] != ELO_START_BYTE)) { | ||
156 | SDL_memcpy(&buffer[0], &buffer[1], num_bytes-1); | ||
157 | } | ||
158 | else { | ||
159 | if (*buffer_p < ELO_PACKET_SIZE-1) { | ||
160 | *checksum = *checksum + buffer[*buffer_p]; | ||
161 | *checksum = *checksum % 256; | ||
162 | } | ||
163 | (*buffer_p)++; | ||
164 | } | ||
165 | num_bytes--; | ||
166 | } | ||
167 | |||
168 | if (*buffer_p == ELO_PACKET_SIZE) { | ||
169 | ok = (*checksum == buffer[ELO_PACKET_SIZE-1]); | ||
170 | *checksum = ELO_INIT_CHECKSUM; | ||
171 | *buffer_p = 0; | ||
172 | |||
173 | if (!ok) { | ||
174 | return 0; | ||
175 | } | ||
176 | |||
177 | return 1; | ||
178 | } | ||
179 | else { | ||
180 | return 0; | ||
181 | } | ||
182 | } | ||
183 | |||
184 | /* eloSendPacket | ||
185 | */ | ||
186 | |||
187 | int eloSendPacket(unsigned char* packet, int fd) | ||
188 | { | ||
189 | int i, result; | ||
190 | int sum = ELO_INIT_CHECKSUM; | ||
191 | |||
192 | packet[0] = ELO_START_BYTE; | ||
193 | for (i = 0; i < ELO_PACKET_SIZE-1; i++) { | ||
194 | sum += packet[i]; | ||
195 | sum &= 0xFF; | ||
196 | } | ||
197 | packet[ELO_PACKET_SIZE-1] = sum; | ||
198 | |||
199 | result = write(fd, packet, ELO_PACKET_SIZE); | ||
200 | |||
201 | if (result != ELO_PACKET_SIZE) { | ||
202 | #ifdef DEBUG_MOUSE | ||
203 | printf("System error while sending to Elographics touchscreen.\n"); | ||
204 | #endif | ||
205 | return 0; | ||
206 | } | ||
207 | else { | ||
208 | return 1; | ||
209 | } | ||
210 | } | ||
211 | |||
212 | |||
213 | /* eloWaitForInput | ||
214 | */ | ||
215 | int eloWaitForInput(int fd, int timeout) | ||
216 | { | ||
217 | fd_set readfds; | ||
218 | struct timeval to; | ||
219 | int r; | ||
220 | |||
221 | FD_ZERO(&readfds); | ||
222 | FD_SET(fd, &readfds); | ||
223 | to.tv_sec = 0; | ||
224 | to.tv_usec = timeout; | ||
225 | |||
226 | r = select(FD_SETSIZE, &readfds, NULL, NULL, &to); | ||
227 | return r; | ||
228 | } | ||
229 | |||
230 | /* eloWaitReply | ||
231 | */ | ||
232 | int eloWaitReply(unsigned char type, unsigned char *reply, int fd) { | ||
233 | int ok; | ||
234 | int i, result; | ||
235 | int reply_p = 0; | ||
236 | int sum = ELO_INIT_CHECKSUM; | ||
237 | |||
238 | i = ELO_MAX_TRIALS; | ||
239 | do { | ||
240 | ok = 0; | ||
241 | |||
242 | result = eloWaitForInput(fd, ELO_MAX_WAIT); | ||
243 | |||
244 | if (result > 0) { | ||
245 | ok = eloGetPacket(reply, &reply_p, &sum, fd); | ||
246 | |||
247 | if (ok && reply[1] != type && type != ELO_PARAMETER) { | ||
248 | #ifdef DEBUG_MOUSE | ||
249 | fprintf(stderr, "Wrong reply received\n"); | ||
250 | #endif | ||
251 | ok = 0; | ||
252 | } | ||
253 | } | ||
254 | else { | ||
255 | #ifdef DEBUG_MOUSE | ||
256 | fprintf(stderr, "No input!\n"); | ||
257 | #endif | ||
258 | } | ||
259 | |||
260 | if (result == 0) { | ||
261 | i--; | ||
262 | } | ||
263 | } while(!ok && (i>0)); | ||
264 | |||
265 | return ok; | ||
266 | } | ||
267 | |||
268 | |||
269 | /* eloWaitAck | ||
270 | */ | ||
271 | |||
272 | int eloWaitAck(int fd) { | ||
273 | unsigned char packet[ELO_PACKET_SIZE]; | ||
274 | int i, nb_errors; | ||
275 | |||
276 | if (eloWaitReply(ELO_ACK, packet, fd)) { | ||
277 | for (i = 0, nb_errors = 0; i < 4; i++) { | ||
278 | if (packet[2 + i] != '0') { | ||
279 | nb_errors++; | ||
280 | } | ||
281 | } | ||
282 | |||
283 | if (nb_errors != 0) { | ||
284 | #ifdef DEBUG_MOUSE | ||
285 | fprintf(stderr, "Elographics acknowledge packet reports %d errors\n", nb_errors); | ||
286 | #endif | ||
287 | } | ||
288 | return 1; | ||
289 | } | ||
290 | else { | ||
291 | return 0; | ||
292 | } | ||
293 | } | ||
294 | |||
295 | |||
296 | /* eloSendQuery -- | ||
297 | */ | ||
298 | int eloSendQuery(unsigned char *request, unsigned char* reply, int fd) { | ||
299 | int ok; | ||
300 | |||
301 | if (eloSendPacket(request, fd)) { | ||
302 | ok = eloWaitReply(toupper(request[1]), reply, fd); | ||
303 | if (ok) { | ||
304 | ok = eloWaitAck(fd); | ||
305 | } | ||
306 | return ok; | ||
307 | } | ||
308 | else { | ||
309 | return 0; | ||
310 | } | ||
311 | } | ||
312 | |||
313 | |||
314 | /* eloSendControl | ||
315 | */ | ||
316 | int eloSendControl(unsigned char* control, int fd) { | ||
317 | if (eloSendPacket(control, fd)) { | ||
318 | return eloWaitAck(fd); | ||
319 | } | ||
320 | else { | ||
321 | return 0; | ||
322 | } | ||
323 | } | ||
324 | |||
325 | /* eloInitController | ||
326 | */ | ||
327 | int eloInitController(int fd) { | ||
328 | unsigned char req[ELO_PACKET_SIZE]; | ||
329 | unsigned char reply[ELO_PACKET_SIZE]; | ||
330 | const char *buffer = NULL; | ||
331 | int result = 0; | ||
332 | |||
333 | struct termios mouse_termios; | ||
334 | |||
335 | /* try to read the calibration values */ | ||
336 | buffer = SDL_getenv("SDL_ELO_MIN_X"); | ||
337 | if(buffer) { | ||
338 | ELO_MIN_X = SDL_atoi(buffer); | ||
339 | } | ||
340 | buffer = SDL_getenv("SDL_ELO_MAX_X"); | ||
341 | if(buffer) { | ||
342 | ELO_MAX_X = SDL_atoi(buffer); | ||
343 | } | ||
344 | buffer = SDL_getenv("SDL_ELO_MIN_Y"); | ||
345 | if(buffer) { | ||
346 | ELO_MIN_Y = SDL_atoi(buffer); | ||
347 | } | ||
348 | buffer = SDL_getenv("SDL_ELO_MAX_Y"); | ||
349 | if(buffer) { | ||
350 | ELO_MAX_Y = SDL_atoi(buffer); | ||
351 | } | ||
352 | |||
353 | #ifdef DEBUG_MOUSE | ||
354 | fprintf( stderr, "ELO calibration values:\nmin_x: %i\nmax_x: %i\nmin_y: %i\nmax_y: %i\n", | ||
355 | ELO_MIN_X, | ||
356 | ELO_MAX_X, | ||
357 | ELO_MIN_Y, | ||
358 | ELO_MAX_Y); | ||
359 | #endif | ||
360 | |||
361 | /* set comm params */ | ||
362 | SDL_memset(&mouse_termios, 0, sizeof(mouse_termios)); | ||
363 | mouse_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; | ||
364 | mouse_termios.c_cc[VMIN] = 1; | ||
365 | result = tcsetattr(fd, TCSANOW, &mouse_termios); | ||
366 | |||
367 | if (result < 0) { | ||
368 | #ifdef DEBUG_MOUSE | ||
369 | fprintf( stderr, "Unable to configure Elographics touchscreen port\n"); | ||
370 | #endif | ||
371 | return 0; | ||
372 | } | ||
373 | |||
374 | SDL_memset(req, 0, ELO_PACKET_SIZE); | ||
375 | req[1] = tolower(ELO_PARAMETER); | ||
376 | if (!eloSendQuery(req, reply, fd)) { | ||
377 | #ifdef DEBUG_MOUSE | ||
378 | fprintf( stderr, "Not at the specified rate or model 2310, will continue\n"); | ||
379 | #endif | ||
380 | } | ||
381 | |||
382 | SDL_memset(req, 0, ELO_PACKET_SIZE); | ||
383 | req[1] = tolower(ELO_ID); | ||
384 | if (eloSendQuery(req, reply, fd)) { | ||
385 | #ifdef DEBUG_MOUSE | ||
386 | fprintf(stderr, "Ok, controller configured!\n"); | ||
387 | #endif | ||
388 | } | ||
389 | else { | ||
390 | #ifdef DEBUG_MOUSE | ||
391 | fprintf( stderr, "Unable to ask Elographics touchscreen identification\n"); | ||
392 | #endif | ||
393 | return 0; | ||
394 | } | ||
395 | |||
396 | SDL_memset(req, 0, ELO_PACKET_SIZE); | ||
397 | req[1] = ELO_MODE; | ||
398 | req[3] = ELO_TOUCH_MODE | ELO_STREAM_MODE | ELO_UNTOUCH_MODE; | ||
399 | req[4] = ELO_TRACKING_MODE; | ||
400 | if (!eloSendControl(req, fd)) { | ||
401 | #ifdef DEBUG_MOUSE | ||
402 | fprintf( stderr, "Unable to change Elographics touchscreen operating mode\n"); | ||
403 | #endif | ||
404 | return 0; | ||
405 | } | ||
406 | |||
407 | SDL_memset(req, 0, ELO_PACKET_SIZE); | ||
408 | req[1] = ELO_REPORT; | ||
409 | req[2] = ELO_UNTOUCH_DELAY; | ||
410 | req[3] = ELO_REPORT_DELAY; | ||
411 | if (!eloSendControl(req, fd)) { | ||
412 | #ifdef DEBUG_MOUSE | ||
413 | fprintf( stderr, "Unable to change Elographics touchscreen reports timings\n"); | ||
414 | #endif | ||
415 | return 0; | ||
416 | } | ||
417 | |||
418 | return 1; | ||
419 | } | ||
420 | |||
421 | int eloReadPosition(_THIS, int fd, int* x, int* y, int* button_state, int* realx, int* realy) { | ||
422 | unsigned char buffer[ELO_PACKET_SIZE]; | ||
423 | int pointer = 0; | ||
424 | int checksum = ELO_INIT_CHECKSUM; | ||
425 | |||
426 | while(pointer < ELO_PACKET_SIZE) { | ||
427 | if(eloGetPacket(buffer, &pointer, &checksum, fd)) { | ||
428 | break; | ||
429 | } | ||
430 | } | ||
431 | |||
432 | if(!eloParsePacket(buffer, realx, realy, button_state)) { | ||
433 | return 0; | ||
434 | } | ||
435 | |||
436 | *x = *realx; | ||
437 | *y = *realy; | ||
438 | |||
439 | eloConvertXY(this, x, y); | ||
440 | |||
441 | return 1; | ||
442 | } | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbelo.h b/apps/plugins/sdl/src/video/fbcon/SDL_fbelo.h deleted file mode 100644 index e7fde4ff2f..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbelo.h +++ /dev/null | |||
@@ -1,55 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #ifndef SDL_fbelo_h | ||
25 | #define SDL_fbelo_h | ||
26 | |||
27 | #include "SDL_fbvideo.h" | ||
28 | |||
29 | /* ELO */ | ||
30 | #define ELO_PACKET_SIZE 10 | ||
31 | #define ELO_START_BYTE 'U' | ||
32 | |||
33 | /* eloConvertXY | ||
34 | Convert the raw coordinates from the ELO controller | ||
35 | to a screen position. | ||
36 | */ | ||
37 | void eloConvertXY(_THIS, int *dx, int *dy); | ||
38 | |||
39 | /* eloInitController(int fd) | ||
40 | Initialize the ELO serial touchscreen controller | ||
41 | */ | ||
42 | int eloInitController(int fd); | ||
43 | |||
44 | /* eloParsePacket | ||
45 | extract position and button state from a packet | ||
46 | */ | ||
47 | int eloParsePacket(unsigned char* mousebuf, int* dx, int* dy, int* button_state); | ||
48 | |||
49 | /* eloReadPosition | ||
50 | read a packet and get the cursor position | ||
51 | */ | ||
52 | |||
53 | int eloReadPosition(_THIS, int fd, int* x, int* y, int* button_state, int* realx, int* realy); | ||
54 | |||
55 | #endif /* SDL_fbelo_h */ | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbevents.c b/apps/plugins/sdl/src/video/fbcon/SDL_fbevents.c deleted file mode 100644 index 5e369a4a89..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbevents.c +++ /dev/null | |||
@@ -1,1254 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* Handle the event stream, converting console events into SDL events */ | ||
25 | |||
26 | #include <stdio.h> | ||
27 | #include <sys/types.h> | ||
28 | #include <sys/time.h> | ||
29 | #include <sys/ioctl.h> | ||
30 | #include <unistd.h> | ||
31 | #include <fcntl.h> | ||
32 | #include <errno.h> | ||
33 | #include <limits.h> | ||
34 | |||
35 | /* For parsing /proc */ | ||
36 | #include <dirent.h> | ||
37 | #include <ctype.h> | ||
38 | |||
39 | #include <linux/vt.h> | ||
40 | #include <linux/kd.h> | ||
41 | #include <linux/keyboard.h> | ||
42 | |||
43 | #include "SDL_timer.h" | ||
44 | #include "SDL_mutex.h" | ||
45 | #include "../SDL_sysvideo.h" | ||
46 | #include "../../events/SDL_sysevents.h" | ||
47 | #include "../../events/SDL_events_c.h" | ||
48 | #include "SDL_fbvideo.h" | ||
49 | #include "SDL_fbevents_c.h" | ||
50 | #include "SDL_fbkeys.h" | ||
51 | |||
52 | #include "SDL_fbelo.h" | ||
53 | |||
54 | #ifndef GPM_NODE_FIFO | ||
55 | #define GPM_NODE_FIFO "/dev/gpmdata" | ||
56 | #endif | ||
57 | |||
58 | /*#define DEBUG_KEYBOARD*/ | ||
59 | /*#define DEBUG_MOUSE*/ | ||
60 | |||
61 | /* The translation tables from a console scancode to a SDL keysym */ | ||
62 | #define NUM_VGAKEYMAPS (1<<KG_CAPSSHIFT) | ||
63 | static Uint16 vga_keymap[NUM_VGAKEYMAPS][NR_KEYS]; | ||
64 | static SDLKey keymap[128]; | ||
65 | static Uint16 keymap_temp[128]; /* only used at startup */ | ||
66 | static SDL_keysym *TranslateKey(int scancode, SDL_keysym *keysym); | ||
67 | |||
68 | /* Ugh, we have to duplicate the kernel's keysym mapping code... | ||
69 | Oh, it's not so bad. :-) | ||
70 | |||
71 | FIXME: Add keyboard LED handling code | ||
72 | */ | ||
73 | static void FB_vgainitkeymaps(int fd) | ||
74 | { | ||
75 | struct kbentry entry; | ||
76 | int map, i; | ||
77 | |||
78 | /* Don't do anything if we are passed a closed keyboard */ | ||
79 | if ( fd < 0 ) { | ||
80 | return; | ||
81 | } | ||
82 | |||
83 | /* Load all the keysym mappings */ | ||
84 | for ( map=0; map<NUM_VGAKEYMAPS; ++map ) { | ||
85 | SDL_memset(vga_keymap[map], 0, NR_KEYS*sizeof(Uint16)); | ||
86 | for ( i=0; i<NR_KEYS; ++i ) { | ||
87 | entry.kb_table = map; | ||
88 | entry.kb_index = i; | ||
89 | if ( ioctl(fd, KDGKBENT, &entry) == 0 ) { | ||
90 | /* fill keytemp. This replaces SDL_fbkeys.h */ | ||
91 | if ( (map == 0) && (i<128) ) { | ||
92 | keymap_temp[i] = entry.kb_value; | ||
93 | } | ||
94 | /* The "Enter" key is a special case */ | ||
95 | if ( entry.kb_value == K_ENTER ) { | ||
96 | entry.kb_value = K(KT_ASCII,13); | ||
97 | } | ||
98 | /* Handle numpad specially as well */ | ||
99 | if ( KTYP(entry.kb_value) == KT_PAD ) { | ||
100 | switch ( entry.kb_value ) { | ||
101 | case K_P0: | ||
102 | case K_P1: | ||
103 | case K_P2: | ||
104 | case K_P3: | ||
105 | case K_P4: | ||
106 | case K_P5: | ||
107 | case K_P6: | ||
108 | case K_P7: | ||
109 | case K_P8: | ||
110 | case K_P9: | ||
111 | vga_keymap[map][i]=entry.kb_value; | ||
112 | vga_keymap[map][i]+= '0'; | ||
113 | break; | ||
114 | case K_PPLUS: | ||
115 | vga_keymap[map][i]=K(KT_ASCII,'+'); | ||
116 | break; | ||
117 | case K_PMINUS: | ||
118 | vga_keymap[map][i]=K(KT_ASCII,'-'); | ||
119 | break; | ||
120 | case K_PSTAR: | ||
121 | vga_keymap[map][i]=K(KT_ASCII,'*'); | ||
122 | break; | ||
123 | case K_PSLASH: | ||
124 | vga_keymap[map][i]=K(KT_ASCII,'/'); | ||
125 | break; | ||
126 | case K_PENTER: | ||
127 | vga_keymap[map][i]=K(KT_ASCII,'\r'); | ||
128 | break; | ||
129 | case K_PCOMMA: | ||
130 | vga_keymap[map][i]=K(KT_ASCII,','); | ||
131 | break; | ||
132 | case K_PDOT: | ||
133 | vga_keymap[map][i]=K(KT_ASCII,'.'); | ||
134 | break; | ||
135 | default: | ||
136 | break; | ||
137 | } | ||
138 | } | ||
139 | /* Do the normal key translation */ | ||
140 | if ( (KTYP(entry.kb_value) == KT_LATIN) || | ||
141 | (KTYP(entry.kb_value) == KT_ASCII) || | ||
142 | (KTYP(entry.kb_value) == KT_LETTER) ) { | ||
143 | vga_keymap[map][i] = entry.kb_value; | ||
144 | } | ||
145 | } | ||
146 | } | ||
147 | } | ||
148 | } | ||
149 | |||
150 | int FB_InGraphicsMode(_THIS) | ||
151 | { | ||
152 | return((keyboard_fd >= 0) && (saved_kbd_mode >= 0)); | ||
153 | } | ||
154 | |||
155 | int FB_EnterGraphicsMode(_THIS) | ||
156 | { | ||
157 | struct termios keyboard_termios; | ||
158 | |||
159 | /* Set medium-raw keyboard mode */ | ||
160 | if ( (keyboard_fd >= 0) && !FB_InGraphicsMode(this) ) { | ||
161 | |||
162 | /* Switch to the correct virtual terminal */ | ||
163 | if ( current_vt > 0 ) { | ||
164 | struct vt_stat vtstate; | ||
165 | |||
166 | if ( ioctl(keyboard_fd, VT_GETSTATE, &vtstate) == 0 ) { | ||
167 | saved_vt = vtstate.v_active; | ||
168 | } | ||
169 | if ( ioctl(keyboard_fd, VT_ACTIVATE, current_vt) == 0 ) { | ||
170 | ioctl(keyboard_fd, VT_WAITACTIVE, current_vt); | ||
171 | } | ||
172 | } | ||
173 | |||
174 | /* Set the terminal input mode */ | ||
175 | if ( tcgetattr(keyboard_fd, &saved_kbd_termios) < 0 ) { | ||
176 | SDL_SetError("Unable to get terminal attributes"); | ||
177 | if ( keyboard_fd > 0 ) { | ||
178 | close(keyboard_fd); | ||
179 | } | ||
180 | keyboard_fd = -1; | ||
181 | return(-1); | ||
182 | } | ||
183 | if ( ioctl(keyboard_fd, KDGKBMODE, &saved_kbd_mode) < 0 ) { | ||
184 | SDL_SetError("Unable to get current keyboard mode"); | ||
185 | if ( keyboard_fd > 0 ) { | ||
186 | close(keyboard_fd); | ||
187 | } | ||
188 | keyboard_fd = -1; | ||
189 | return(-1); | ||
190 | } | ||
191 | keyboard_termios = saved_kbd_termios; | ||
192 | keyboard_termios.c_lflag &= ~(ICANON | ECHO | ISIG); | ||
193 | keyboard_termios.c_iflag &= ~(ISTRIP | IGNCR | ICRNL | INLCR | IXOFF | IXON); | ||
194 | keyboard_termios.c_cc[VMIN] = 0; | ||
195 | keyboard_termios.c_cc[VTIME] = 0; | ||
196 | if (tcsetattr(keyboard_fd, TCSAFLUSH, &keyboard_termios) < 0) { | ||
197 | FB_CloseKeyboard(this); | ||
198 | SDL_SetError("Unable to set terminal attributes"); | ||
199 | return(-1); | ||
200 | } | ||
201 | /* This will fail if we aren't root or this isn't our tty */ | ||
202 | if ( ioctl(keyboard_fd, KDSKBMODE, K_MEDIUMRAW) < 0 ) { | ||
203 | FB_CloseKeyboard(this); | ||
204 | SDL_SetError("Unable to set keyboard in raw mode"); | ||
205 | return(-1); | ||
206 | } | ||
207 | if ( ioctl(keyboard_fd, KDSETMODE, KD_GRAPHICS) < 0 ) { | ||
208 | FB_CloseKeyboard(this); | ||
209 | SDL_SetError("Unable to set keyboard in graphics mode"); | ||
210 | return(-1); | ||
211 | } | ||
212 | /* Prevent switching the virtual terminal */ | ||
213 | ioctl(keyboard_fd, VT_LOCKSWITCH, 1); | ||
214 | } | ||
215 | return(keyboard_fd); | ||
216 | } | ||
217 | |||
218 | void FB_LeaveGraphicsMode(_THIS) | ||
219 | { | ||
220 | if ( FB_InGraphicsMode(this) ) { | ||
221 | ioctl(keyboard_fd, KDSETMODE, KD_TEXT); | ||
222 | ioctl(keyboard_fd, KDSKBMODE, saved_kbd_mode); | ||
223 | tcsetattr(keyboard_fd, TCSAFLUSH, &saved_kbd_termios); | ||
224 | saved_kbd_mode = -1; | ||
225 | |||
226 | /* Head back over to the original virtual terminal */ | ||
227 | ioctl(keyboard_fd, VT_UNLOCKSWITCH, 1); | ||
228 | if ( saved_vt > 0 ) { | ||
229 | ioctl(keyboard_fd, VT_ACTIVATE, saved_vt); | ||
230 | } | ||
231 | } | ||
232 | } | ||
233 | |||
234 | void FB_CloseKeyboard(_THIS) | ||
235 | { | ||
236 | if ( keyboard_fd >= 0 ) { | ||
237 | FB_LeaveGraphicsMode(this); | ||
238 | if ( keyboard_fd > 0 ) { | ||
239 | close(keyboard_fd); | ||
240 | } | ||
241 | } | ||
242 | keyboard_fd = -1; | ||
243 | } | ||
244 | |||
245 | int FB_OpenKeyboard(_THIS) | ||
246 | { | ||
247 | /* Open only if not already opened */ | ||
248 | if ( keyboard_fd < 0 ) { | ||
249 | static const char * const tty0[] = { "/dev/tty0", "/dev/vc/0", NULL }; | ||
250 | static const char * const vcs[] = { "/dev/vc/%d", "/dev/tty%d", NULL }; | ||
251 | int i, tty0_fd; | ||
252 | |||
253 | /* Try to query for a free virtual terminal */ | ||
254 | tty0_fd = -1; | ||
255 | for ( i=0; tty0[i] && (tty0_fd < 0); ++i ) { | ||
256 | tty0_fd = open(tty0[i], O_WRONLY, 0); | ||
257 | } | ||
258 | if ( tty0_fd < 0 ) { | ||
259 | tty0_fd = dup(0); /* Maybe stdin is a VT? */ | ||
260 | } | ||
261 | ioctl(tty0_fd, VT_OPENQRY, ¤t_vt); | ||
262 | close(tty0_fd); | ||
263 | if ( (geteuid() == 0) && (current_vt > 0) ) { | ||
264 | for ( i=0; vcs[i] && (keyboard_fd < 0); ++i ) { | ||
265 | char vtpath[12]; | ||
266 | |||
267 | SDL_snprintf(vtpath, SDL_arraysize(vtpath), vcs[i], current_vt); | ||
268 | keyboard_fd = open(vtpath, O_RDWR, 0); | ||
269 | #ifdef DEBUG_KEYBOARD | ||
270 | fprintf(stderr, "vtpath = %s, fd = %d\n", | ||
271 | vtpath, keyboard_fd); | ||
272 | #endif /* DEBUG_KEYBOARD */ | ||
273 | |||
274 | /* This needs to be our controlling tty | ||
275 | so that the kernel ioctl() calls work | ||
276 | */ | ||
277 | if ( keyboard_fd >= 0 ) { | ||
278 | tty0_fd = open("/dev/tty", O_RDWR, 0); | ||
279 | if ( tty0_fd >= 0 ) { | ||
280 | ioctl(tty0_fd, TIOCNOTTY, 0); | ||
281 | close(tty0_fd); | ||
282 | } | ||
283 | } | ||
284 | } | ||
285 | } | ||
286 | if ( keyboard_fd < 0 ) { | ||
287 | /* Last resort, maybe our tty is a usable VT */ | ||
288 | struct vt_stat vtstate; | ||
289 | |||
290 | keyboard_fd = open("/dev/tty", O_RDWR); | ||
291 | |||
292 | if ( ioctl(keyboard_fd, VT_GETSTATE, &vtstate) == 0 ) { | ||
293 | current_vt = vtstate.v_active; | ||
294 | } else { | ||
295 | current_vt = 0; | ||
296 | } | ||
297 | } | ||
298 | #ifdef DEBUG_KEYBOARD | ||
299 | fprintf(stderr, "Current VT: %d\n", current_vt); | ||
300 | #endif | ||
301 | saved_kbd_mode = -1; | ||
302 | |||
303 | /* Make sure that our input is a console terminal */ | ||
304 | { int dummy; | ||
305 | if ( ioctl(keyboard_fd, KDGKBMODE, &dummy) < 0 ) { | ||
306 | close(keyboard_fd); | ||
307 | keyboard_fd = -1; | ||
308 | SDL_SetError("Unable to open a console terminal"); | ||
309 | } | ||
310 | } | ||
311 | |||
312 | /* Set up keymap */ | ||
313 | FB_vgainitkeymaps(keyboard_fd); | ||
314 | } | ||
315 | return(keyboard_fd); | ||
316 | } | ||
317 | |||
318 | static enum { | ||
319 | MOUSE_NONE = -1, | ||
320 | MOUSE_MSC, /* Note: GPM uses the MSC protocol */ | ||
321 | MOUSE_PS2, | ||
322 | MOUSE_IMPS2, | ||
323 | MOUSE_MS, | ||
324 | MOUSE_BM, | ||
325 | MOUSE_ELO, | ||
326 | MOUSE_TSLIB, | ||
327 | NUM_MOUSE_DRVS | ||
328 | } mouse_drv = MOUSE_NONE; | ||
329 | |||
330 | void FB_CloseMouse(_THIS) | ||
331 | { | ||
332 | #if SDL_INPUT_TSLIB | ||
333 | if (ts_dev != NULL) { | ||
334 | ts_close(ts_dev); | ||
335 | ts_dev = NULL; | ||
336 | mouse_fd = -1; | ||
337 | } | ||
338 | #endif /* SDL_INPUT_TSLIB */ | ||
339 | if ( mouse_fd > 0 ) { | ||
340 | close(mouse_fd); | ||
341 | } | ||
342 | mouse_fd = -1; | ||
343 | } | ||
344 | |||
345 | /* Returns processes listed in /proc with the desired name */ | ||
346 | static int find_pid(DIR *proc, const char *wanted_name) | ||
347 | { | ||
348 | struct dirent *entry; | ||
349 | int pid; | ||
350 | |||
351 | /* First scan proc for the gpm process */ | ||
352 | pid = 0; | ||
353 | while ( (pid == 0) && ((entry=readdir(proc)) != NULL) ) { | ||
354 | if ( isdigit(entry->d_name[0]) ) { | ||
355 | FILE *status; | ||
356 | char path[PATH_MAX]; | ||
357 | char name[PATH_MAX]; | ||
358 | |||
359 | SDL_snprintf(path, SDL_arraysize(path), "/proc/%s/status", entry->d_name); | ||
360 | status=fopen(path, "r"); | ||
361 | if ( status ) { | ||
362 | int matches = 0; | ||
363 | name[0] = '\0'; | ||
364 | matches = fscanf(status, "Name: %s", name); | ||
365 | if ( (matches == 1) && (SDL_strcmp(name, wanted_name) == 0) ) { | ||
366 | pid = SDL_atoi(entry->d_name); | ||
367 | } | ||
368 | fclose(status); | ||
369 | } | ||
370 | } | ||
371 | } | ||
372 | return pid; | ||
373 | } | ||
374 | |||
375 | /* Returns true if /dev/gpmdata is being written to by gpm */ | ||
376 | static int gpm_available(char *proto, size_t protolen) | ||
377 | { | ||
378 | int available; | ||
379 | DIR *proc; | ||
380 | int pid; | ||
381 | int cmdline, len, arglen; | ||
382 | char path[PATH_MAX]; | ||
383 | char args[PATH_MAX], *arg; | ||
384 | |||
385 | /* Don't bother looking if the fifo isn't there */ | ||
386 | #ifdef DEBUG_MOUSE | ||
387 | fprintf(stderr,"testing gpm\n"); | ||
388 | #endif | ||
389 | if ( access(GPM_NODE_FIFO, F_OK) < 0 ) { | ||
390 | return(0); | ||
391 | } | ||
392 | |||
393 | available = 0; | ||
394 | proc = opendir("/proc"); | ||
395 | if ( proc ) { | ||
396 | char raw_proto[10] = { '\0' }; | ||
397 | char repeat_proto[10] = { '\0' }; | ||
398 | while ( !available && (pid=find_pid(proc, "gpm")) > 0 ) { | ||
399 | SDL_snprintf(path, SDL_arraysize(path), "/proc/%d/cmdline", pid); | ||
400 | cmdline = open(path, O_RDONLY, 0); | ||
401 | if ( cmdline >= 0 ) { | ||
402 | len = read(cmdline, args, sizeof(args)); | ||
403 | arg = args; | ||
404 | while ( len > 0 ) { | ||
405 | arglen = SDL_strlen(arg)+1; | ||
406 | #ifdef DEBUG_MOUSE | ||
407 | fprintf(stderr,"gpm arg %s len %d\n",arg,arglen); | ||
408 | #endif | ||
409 | if ( SDL_strcmp(arg, "-t") == 0) { | ||
410 | /* protocol string, keep it for later */ | ||
411 | char *t, *s; | ||
412 | t = arg + arglen; | ||
413 | s = SDL_strchr(t, ' '); | ||
414 | if (s) *s = 0; | ||
415 | SDL_strlcpy(raw_proto, t, SDL_arraysize(raw_proto)); | ||
416 | if (s) *s = ' '; | ||
417 | } | ||
418 | if ( SDL_strncmp(arg, "-R", 2) == 0 ) { | ||
419 | char *t, *s; | ||
420 | available = 1; | ||
421 | t = arg + 2; | ||
422 | s = SDL_strchr(t, ' '); | ||
423 | if (s) *s = 0; | ||
424 | SDL_strlcpy(repeat_proto, t, SDL_arraysize(repeat_proto)); | ||
425 | if (s) *s = ' '; | ||
426 | } | ||
427 | len -= arglen; | ||
428 | arg += arglen; | ||
429 | } | ||
430 | close(cmdline); | ||
431 | } | ||
432 | } | ||
433 | closedir(proc); | ||
434 | |||
435 | if ( available ) { | ||
436 | if ( SDL_strcmp(repeat_proto, "raw") == 0 ) { | ||
437 | SDL_strlcpy(proto, raw_proto, protolen); | ||
438 | } else if ( *repeat_proto ) { | ||
439 | SDL_strlcpy(proto, repeat_proto, protolen); | ||
440 | } else { | ||
441 | SDL_strlcpy(proto, "msc", protolen); | ||
442 | } | ||
443 | } | ||
444 | } | ||
445 | return available; | ||
446 | } | ||
447 | |||
448 | |||
449 | /* rcg06112001 Set up IMPS/2 mode, if possible. This gives | ||
450 | * us access to the mousewheel, etc. Returns zero if | ||
451 | * writes to device failed, but you still need to query the | ||
452 | * device to see which mode it's actually in. | ||
453 | */ | ||
454 | static int set_imps2_mode(int fd) | ||
455 | { | ||
456 | /* If you wanted to control the mouse mode (and we do :) ) ... | ||
457 | Set IMPS/2 protocol: | ||
458 | {0xf3,200,0xf3,100,0xf3,80} | ||
459 | Reset mouse device: | ||
460 | {0xFF} | ||
461 | */ | ||
462 | Uint8 set_imps2[] = {0xf3, 200, 0xf3, 100, 0xf3, 80}; | ||
463 | /*Uint8 reset = 0xff;*/ | ||
464 | fd_set fdset; | ||
465 | struct timeval tv; | ||
466 | int retval = 0; | ||
467 | |||
468 | if ( write(fd, &set_imps2, sizeof(set_imps2)) == sizeof(set_imps2) ) { | ||
469 | /* Don't reset it, that'll clear IMPS/2 mode on some mice | ||
470 | if (write(fd, &reset, sizeof (reset)) == sizeof (reset) ) { | ||
471 | retval = 1; | ||
472 | } | ||
473 | */ | ||
474 | } | ||
475 | |||
476 | /* Get rid of any chatter from the above */ | ||
477 | FD_ZERO(&fdset); | ||
478 | FD_SET(fd, &fdset); | ||
479 | tv.tv_sec = 0; | ||
480 | tv.tv_usec = 0; | ||
481 | while ( select(fd+1, &fdset, 0, 0, &tv) > 0 ) { | ||
482 | char temp[32]; | ||
483 | if (read(fd, temp, sizeof(temp)) <= 0) { | ||
484 | break; | ||
485 | } | ||
486 | } | ||
487 | |||
488 | return retval; | ||
489 | } | ||
490 | |||
491 | |||
492 | /* Returns true if the mouse uses the IMPS/2 protocol */ | ||
493 | static int detect_imps2(int fd) | ||
494 | { | ||
495 | int imps2; | ||
496 | |||
497 | imps2 = 0; | ||
498 | |||
499 | if ( SDL_getenv("SDL_MOUSEDEV_IMPS2") ) { | ||
500 | imps2 = 1; | ||
501 | } | ||
502 | if ( ! imps2 ) { | ||
503 | Uint8 query_ps2 = 0xF2; | ||
504 | fd_set fdset; | ||
505 | struct timeval tv; | ||
506 | |||
507 | /* Get rid of any mouse motion noise */ | ||
508 | FD_ZERO(&fdset); | ||
509 | FD_SET(fd, &fdset); | ||
510 | tv.tv_sec = 0; | ||
511 | tv.tv_usec = 0; | ||
512 | while ( select(fd+1, &fdset, 0, 0, &tv) > 0 ) { | ||
513 | char temp[32]; | ||
514 | if (read(fd, temp, sizeof(temp)) <= 0) { | ||
515 | break; | ||
516 | } | ||
517 | } | ||
518 | |||
519 | /* Query for the type of mouse protocol */ | ||
520 | if ( write(fd, &query_ps2, sizeof (query_ps2)) == sizeof (query_ps2)) { | ||
521 | Uint8 ch = 0; | ||
522 | |||
523 | /* Get the mouse protocol response */ | ||
524 | do { | ||
525 | FD_ZERO(&fdset); | ||
526 | FD_SET(fd, &fdset); | ||
527 | tv.tv_sec = 1; | ||
528 | tv.tv_usec = 0; | ||
529 | if ( select(fd+1, &fdset, 0, 0, &tv) < 1 ) { | ||
530 | break; | ||
531 | } | ||
532 | } while ( (read(fd, &ch, sizeof (ch)) == sizeof (ch)) && | ||
533 | ((ch == 0xFA) || (ch == 0xAA)) ); | ||
534 | |||
535 | /* Experimental values (Logitech wheelmouse) */ | ||
536 | #ifdef DEBUG_MOUSE | ||
537 | fprintf(stderr, "Last mouse mode: 0x%x\n", ch); | ||
538 | #endif | ||
539 | if ( (ch == 3) || (ch == 4) ) { | ||
540 | imps2 = 1; | ||
541 | } | ||
542 | } | ||
543 | } | ||
544 | return imps2; | ||
545 | } | ||
546 | |||
547 | int FB_OpenMouse(_THIS) | ||
548 | { | ||
549 | int i; | ||
550 | const char *mousedev; | ||
551 | const char *mousedrv; | ||
552 | |||
553 | mousedrv = SDL_getenv("SDL_MOUSEDRV"); | ||
554 | mousedev = SDL_getenv("SDL_MOUSEDEV"); | ||
555 | mouse_fd = -1; | ||
556 | |||
557 | #if SDL_INPUT_TSLIB | ||
558 | if ( mousedrv && (SDL_strcmp(mousedrv, "TSLIB") == 0) ) { | ||
559 | if (mousedev == NULL) mousedev = SDL_getenv("TSLIB_TSDEVICE"); | ||
560 | if (mousedev != NULL) { | ||
561 | ts_dev = ts_open(mousedev, 1); | ||
562 | if ((ts_dev != NULL) && (ts_config(ts_dev) >= 0)) { | ||
563 | #ifdef DEBUG_MOUSE | ||
564 | fprintf(stderr, "Using tslib touchscreen\n"); | ||
565 | #endif | ||
566 | mouse_drv = MOUSE_TSLIB; | ||
567 | mouse_fd = ts_fd(ts_dev); | ||
568 | return mouse_fd; | ||
569 | } | ||
570 | } | ||
571 | mouse_drv = MOUSE_NONE; | ||
572 | return mouse_fd; | ||
573 | } | ||
574 | #endif /* SDL_INPUT_TSLIB */ | ||
575 | |||
576 | /* ELO TOUCHSCREEN SUPPORT */ | ||
577 | |||
578 | if ( mousedrv && (SDL_strcmp(mousedrv, "ELO") == 0) ) { | ||
579 | mouse_fd = open(mousedev, O_RDWR); | ||
580 | if ( mouse_fd >= 0 ) { | ||
581 | if(eloInitController(mouse_fd)) { | ||
582 | #ifdef DEBUG_MOUSE | ||
583 | fprintf(stderr, "Using ELO touchscreen\n"); | ||
584 | #endif | ||
585 | mouse_drv = MOUSE_ELO; | ||
586 | } | ||
587 | |||
588 | } | ||
589 | else if ( mouse_fd < 0 ) { | ||
590 | mouse_drv = MOUSE_NONE; | ||
591 | } | ||
592 | |||
593 | return(mouse_fd); | ||
594 | } | ||
595 | |||
596 | /* STD MICE */ | ||
597 | |||
598 | if ( mousedev == NULL ) { | ||
599 | /* FIXME someday... allow multiple mice in this driver */ | ||
600 | static const char *ps2mice[] = { | ||
601 | "/dev/input/mice", "/dev/usbmouse", "/dev/psaux", NULL | ||
602 | }; | ||
603 | /* First try to use GPM in repeater mode */ | ||
604 | if ( mouse_fd < 0 ) { | ||
605 | char proto[10]; | ||
606 | if ( gpm_available(proto, SDL_arraysize(proto)) ) { | ||
607 | mouse_fd = open(GPM_NODE_FIFO, O_RDONLY, 0); | ||
608 | if ( mouse_fd >= 0 ) { | ||
609 | if ( SDL_strcmp(proto, "msc") == 0 ) { | ||
610 | mouse_drv = MOUSE_MSC; | ||
611 | } else if ( SDL_strcmp(proto, "ps2") == 0 ) { | ||
612 | mouse_drv = MOUSE_PS2; | ||
613 | } else if ( SDL_strcmp(proto, "imps2") == 0 ) { | ||
614 | mouse_drv = MOUSE_IMPS2; | ||
615 | } else if ( SDL_strcmp(proto, "ms") == 0 || | ||
616 | SDL_strcmp(proto, "bare") == 0 ) { | ||
617 | mouse_drv = MOUSE_MS; | ||
618 | } else if ( SDL_strcmp(proto, "bm") == 0 ) { | ||
619 | mouse_drv = MOUSE_BM; | ||
620 | } else { | ||
621 | /* Unknown protocol... */ | ||
622 | #ifdef DEBUG_MOUSE | ||
623 | fprintf(stderr, "GPM mouse using unknown protocol = %s\n", proto); | ||
624 | #endif | ||
625 | close(mouse_fd); | ||
626 | mouse_fd = -1; | ||
627 | } | ||
628 | } | ||
629 | #ifdef DEBUG_MOUSE | ||
630 | if ( mouse_fd >= 0 ) { | ||
631 | fprintf(stderr, "Using GPM mouse, protocol = %s\n", proto); | ||
632 | } | ||
633 | #endif /* DEBUG_MOUSE */ | ||
634 | } | ||
635 | } | ||
636 | /* Now try to use a modern PS/2 mouse */ | ||
637 | for ( i=0; (mouse_fd < 0) && ps2mice[i]; ++i ) { | ||
638 | mouse_fd = open(ps2mice[i], O_RDWR, 0); | ||
639 | if (mouse_fd < 0) { | ||
640 | mouse_fd = open(ps2mice[i], O_RDONLY, 0); | ||
641 | } | ||
642 | if (mouse_fd >= 0) { | ||
643 | /* rcg06112001 Attempt to set IMPS/2 mode */ | ||
644 | set_imps2_mode(mouse_fd); | ||
645 | if (detect_imps2(mouse_fd)) { | ||
646 | #ifdef DEBUG_MOUSE | ||
647 | fprintf(stderr, "Using IMPS2 mouse\n"); | ||
648 | #endif | ||
649 | mouse_drv = MOUSE_IMPS2; | ||
650 | } else { | ||
651 | #ifdef DEBUG_MOUSE | ||
652 | fprintf(stderr, "Using PS2 mouse\n"); | ||
653 | #endif | ||
654 | mouse_drv = MOUSE_PS2; | ||
655 | } | ||
656 | } | ||
657 | } | ||
658 | /* Next try to use a PPC ADB port mouse */ | ||
659 | if ( mouse_fd < 0 ) { | ||
660 | mouse_fd = open("/dev/adbmouse", O_RDONLY, 0); | ||
661 | if ( mouse_fd >= 0 ) { | ||
662 | #ifdef DEBUG_MOUSE | ||
663 | fprintf(stderr, "Using ADB mouse\n"); | ||
664 | #endif | ||
665 | mouse_drv = MOUSE_BM; | ||
666 | } | ||
667 | } | ||
668 | } | ||
669 | /* Default to a serial Microsoft mouse */ | ||
670 | if ( mouse_fd < 0 ) { | ||
671 | if ( mousedev == NULL ) { | ||
672 | mousedev = "/dev/mouse"; | ||
673 | } | ||
674 | mouse_fd = open(mousedev, O_RDONLY, 0); | ||
675 | if ( mouse_fd >= 0 ) { | ||
676 | struct termios mouse_termios; | ||
677 | |||
678 | /* Set the sampling speed to 1200 baud */ | ||
679 | tcgetattr(mouse_fd, &mouse_termios); | ||
680 | mouse_termios.c_iflag = IGNBRK | IGNPAR; | ||
681 | mouse_termios.c_oflag = 0; | ||
682 | mouse_termios.c_lflag = 0; | ||
683 | mouse_termios.c_line = 0; | ||
684 | mouse_termios.c_cc[VTIME] = 0; | ||
685 | mouse_termios.c_cc[VMIN] = 1; | ||
686 | mouse_termios.c_cflag = CREAD | CLOCAL | HUPCL; | ||
687 | mouse_termios.c_cflag |= CS8; | ||
688 | mouse_termios.c_cflag |= B1200; | ||
689 | tcsetattr(mouse_fd, TCSAFLUSH, &mouse_termios); | ||
690 | if ( mousedrv && (SDL_strcmp(mousedrv, "PS2") == 0) ) { | ||
691 | #ifdef DEBUG_MOUSE | ||
692 | fprintf(stderr, "Using (user specified) PS2 mouse on %s\n", mousedev); | ||
693 | #endif | ||
694 | mouse_drv = MOUSE_PS2; | ||
695 | } else { | ||
696 | #ifdef DEBUG_MOUSE | ||
697 | fprintf(stderr, "Using (default) MS mouse on %s\n", mousedev); | ||
698 | #endif | ||
699 | mouse_drv = MOUSE_MS; | ||
700 | } | ||
701 | } | ||
702 | } | ||
703 | if ( mouse_fd < 0 ) { | ||
704 | mouse_drv = MOUSE_NONE; | ||
705 | } | ||
706 | return(mouse_fd); | ||
707 | } | ||
708 | |||
709 | static int posted = 0; | ||
710 | |||
711 | void FB_vgamousecallback(int button, int relative, int dx, int dy) | ||
712 | { | ||
713 | int button_1, button_3; | ||
714 | int button_state; | ||
715 | int state_changed; | ||
716 | int i; | ||
717 | Uint8 state; | ||
718 | |||
719 | if ( dx || dy ) { | ||
720 | posted += SDL_PrivateMouseMotion(0, relative, dx, dy); | ||
721 | } | ||
722 | |||
723 | /* Swap button 1 and 3 */ | ||
724 | button_1 = (button & 0x04) >> 2; | ||
725 | button_3 = (button & 0x01) << 2; | ||
726 | button &= ~0x05; | ||
727 | button |= (button_1|button_3); | ||
728 | |||
729 | /* See what changed */ | ||
730 | button_state = SDL_GetMouseState(NULL, NULL); | ||
731 | state_changed = button_state ^ button; | ||
732 | for ( i=0; i<8; ++i ) { | ||
733 | if ( state_changed & (1<<i) ) { | ||
734 | if ( button & (1<<i) ) { | ||
735 | state = SDL_PRESSED; | ||
736 | } else { | ||
737 | state = SDL_RELEASED; | ||
738 | } | ||
739 | posted += SDL_PrivateMouseButton(state, i+1, 0, 0); | ||
740 | } | ||
741 | } | ||
742 | } | ||
743 | |||
744 | /* Handle input from tslib */ | ||
745 | #if SDL_INPUT_TSLIB | ||
746 | static void handle_tslib(_THIS) | ||
747 | { | ||
748 | struct ts_sample sample; | ||
749 | int button; | ||
750 | |||
751 | while (ts_read(ts_dev, &sample, 1) > 0) { | ||
752 | button = (sample.pressure > 0) ? 1 : 0; | ||
753 | button <<= 2; /* must report it as button 3 */ | ||
754 | FB_vgamousecallback(button, 0, sample.x, sample.y); | ||
755 | } | ||
756 | return; | ||
757 | } | ||
758 | #endif /* SDL_INPUT_TSLIB */ | ||
759 | |||
760 | /* For now, use MSC, PS/2, and MS protocols | ||
761 | Driver adapted from the SVGAlib mouse driver code (taken from gpm, etc.) | ||
762 | */ | ||
763 | static void handle_mouse(_THIS) | ||
764 | { | ||
765 | static int start = 0; | ||
766 | static unsigned char mousebuf[BUFSIZ]; | ||
767 | static int relative = 1; | ||
768 | |||
769 | int i, nread; | ||
770 | int button = 0; | ||
771 | int dx = 0, dy = 0; | ||
772 | int packetsize = 0; | ||
773 | int realx, realy; | ||
774 | |||
775 | /* Figure out the mouse packet size */ | ||
776 | switch (mouse_drv) { | ||
777 | case MOUSE_NONE: | ||
778 | break; /* carry on to read from device and discard it. */ | ||
779 | case MOUSE_MSC: | ||
780 | packetsize = 5; | ||
781 | break; | ||
782 | case MOUSE_IMPS2: | ||
783 | packetsize = 4; | ||
784 | break; | ||
785 | case MOUSE_PS2: | ||
786 | case MOUSE_MS: | ||
787 | case MOUSE_BM: | ||
788 | packetsize = 3; | ||
789 | break; | ||
790 | case MOUSE_ELO: | ||
791 | /* try to read the next packet */ | ||
792 | if(eloReadPosition(this, mouse_fd, &dx, &dy, &button, &realx, &realy)) { | ||
793 | button = (button & 0x01) << 2; | ||
794 | FB_vgamousecallback(button, 0, dx, dy); | ||
795 | } | ||
796 | return; /* nothing left to do */ | ||
797 | case MOUSE_TSLIB: | ||
798 | #if SDL_INPUT_TSLIB | ||
799 | handle_tslib(this); | ||
800 | #endif | ||
801 | return; /* nothing left to do */ | ||
802 | default: | ||
803 | /* Uh oh.. */ | ||
804 | packetsize = 0; | ||
805 | break; | ||
806 | } | ||
807 | |||
808 | /* Special handling for the quite sensitive ELO controller */ | ||
809 | if (mouse_drv == MOUSE_ELO) { | ||
810 | |||
811 | } | ||
812 | |||
813 | /* Read as many packets as possible */ | ||
814 | nread = read(mouse_fd, &mousebuf[start], BUFSIZ-start); | ||
815 | if ( nread < 0 ) { | ||
816 | return; | ||
817 | } | ||
818 | |||
819 | if (mouse_drv == MOUSE_NONE) { | ||
820 | return; /* we're done; just draining the input queue. */ | ||
821 | } | ||
822 | |||
823 | nread += start; | ||
824 | #ifdef DEBUG_MOUSE | ||
825 | fprintf(stderr, "Read %d bytes from mouse, start = %d\n", nread, start); | ||
826 | #endif | ||
827 | |||
828 | for ( i=0; i<(nread-(packetsize-1)); i += packetsize ) { | ||
829 | switch (mouse_drv) { | ||
830 | case MOUSE_NONE: /* shouldn't actually hit this. */ | ||
831 | break; /* just throw everything away. */ | ||
832 | case MOUSE_MSC: | ||
833 | /* MSC protocol has 0x80 in high byte */ | ||
834 | if ( (mousebuf[i] & 0xF8) != 0x80 ) { | ||
835 | /* Go to next byte */ | ||
836 | i -= (packetsize-1); | ||
837 | continue; | ||
838 | } | ||
839 | /* Get current mouse state */ | ||
840 | button = (~mousebuf[i]) & 0x07; | ||
841 | dx = (signed char)(mousebuf[i+1]) + | ||
842 | (signed char)(mousebuf[i+3]); | ||
843 | dy = -((signed char)(mousebuf[i+2]) + | ||
844 | (signed char)(mousebuf[i+4])); | ||
845 | break; | ||
846 | case MOUSE_PS2: | ||
847 | /* PS/2 protocol has nothing in high byte */ | ||
848 | if ( (mousebuf[i] & 0xC0) != 0 ) { | ||
849 | /* Go to next byte */ | ||
850 | i -= (packetsize-1); | ||
851 | continue; | ||
852 | } | ||
853 | /* Get current mouse state */ | ||
854 | button = (mousebuf[i] & 0x04) >> 1 | /*Middle*/ | ||
855 | (mousebuf[i] & 0x02) >> 1 | /*Right*/ | ||
856 | (mousebuf[i] & 0x01) << 2; /*Left*/ | ||
857 | dx = (mousebuf[i] & 0x10) ? | ||
858 | mousebuf[i+1] - 256 : mousebuf[i+1]; | ||
859 | dy = (mousebuf[i] & 0x20) ? | ||
860 | -(mousebuf[i+2] - 256) : -mousebuf[i+2]; | ||
861 | break; | ||
862 | case MOUSE_IMPS2: | ||
863 | /* Get current mouse state */ | ||
864 | button = (mousebuf[i] & 0x04) >> 1 | /*Middle*/ | ||
865 | (mousebuf[i] & 0x02) >> 1 | /*Right*/ | ||
866 | (mousebuf[i] & 0x01) << 2 | /*Left*/ | ||
867 | (mousebuf[i] & 0x40) >> 3 | /* 4 */ | ||
868 | (mousebuf[i] & 0x80) >> 3; /* 5 */ | ||
869 | dx = (mousebuf[i] & 0x10) ? | ||
870 | mousebuf[i+1] - 256 : mousebuf[i+1]; | ||
871 | dy = (mousebuf[i] & 0x20) ? | ||
872 | -(mousebuf[i+2] - 256) : -mousebuf[i+2]; | ||
873 | switch (mousebuf[i+3]&0x0F) { | ||
874 | case 0x0E: /* DX = +1 */ | ||
875 | case 0x02: /* DX = -1 */ | ||
876 | break; | ||
877 | case 0x0F: /* DY = +1 (map button 4) */ | ||
878 | FB_vgamousecallback(button | (1<<3), | ||
879 | 1, 0, 0); | ||
880 | break; | ||
881 | case 0x01: /* DY = -1 (map button 5) */ | ||
882 | FB_vgamousecallback(button | (1<<4), | ||
883 | 1, 0, 0); | ||
884 | break; | ||
885 | } | ||
886 | break; | ||
887 | case MOUSE_MS: | ||
888 | /* Microsoft protocol has 0x40 in high byte */ | ||
889 | if ( (mousebuf[i] & 0x40) != 0x40 ) { | ||
890 | /* Go to next byte */ | ||
891 | i -= (packetsize-1); | ||
892 | continue; | ||
893 | } | ||
894 | /* Get current mouse state */ | ||
895 | button = ((mousebuf[i] & 0x20) >> 3) | | ||
896 | ((mousebuf[i] & 0x10) >> 4); | ||
897 | dx = (signed char)(((mousebuf[i] & 0x03) << 6) | | ||
898 | (mousebuf[i + 1] & 0x3F)); | ||
899 | dy = (signed char)(((mousebuf[i] & 0x0C) << 4) | | ||
900 | (mousebuf[i + 2] & 0x3F)); | ||
901 | break; | ||
902 | case MOUSE_BM: | ||
903 | /* BusMouse protocol has 0xF8 in high byte */ | ||
904 | if ( (mousebuf[i] & 0xF8) != 0x80 ) { | ||
905 | /* Go to next byte */ | ||
906 | i -= (packetsize-1); | ||
907 | continue; | ||
908 | } | ||
909 | /* Get current mouse state */ | ||
910 | button = (~mousebuf[i]) & 0x07; | ||
911 | dx = (signed char)mousebuf[i+1]; | ||
912 | dy = -(signed char)mousebuf[i+2]; | ||
913 | break; | ||
914 | default: | ||
915 | /* Uh oh.. */ | ||
916 | dx = 0; | ||
917 | dy = 0; | ||
918 | break; | ||
919 | } | ||
920 | FB_vgamousecallback(button, relative, dx, dy); | ||
921 | } | ||
922 | if ( i < nread ) { | ||
923 | SDL_memcpy(mousebuf, &mousebuf[i], (nread-i)); | ||
924 | start = (nread-i); | ||
925 | } else { | ||
926 | start = 0; | ||
927 | } | ||
928 | return; | ||
929 | } | ||
930 | |||
931 | /* Handle switching to another VC, returns when our VC is back */ | ||
932 | static void switch_vt_prep(_THIS) | ||
933 | { | ||
934 | SDL_Surface *screen = SDL_VideoSurface; | ||
935 | |||
936 | SDL_PrivateAppActive(0, (SDL_APPACTIVE|SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS)); | ||
937 | |||
938 | /* Save the contents of the screen, and go to text mode */ | ||
939 | wait_idle(this); | ||
940 | screen_arealen = ((screen->h + (2*this->offset_y)) * screen->pitch); | ||
941 | screen_contents = (Uint8 *)SDL_malloc(screen_arealen); | ||
942 | if ( screen_contents ) { | ||
943 | SDL_memcpy(screen_contents, screen->pixels, screen_arealen); | ||
944 | } | ||
945 | FB_SavePaletteTo(this, 256, screen_palette); | ||
946 | ioctl(console_fd, FBIOGET_VSCREENINFO, &screen_vinfo); | ||
947 | ioctl(keyboard_fd, KDSETMODE, KD_TEXT); | ||
948 | ioctl(keyboard_fd, VT_UNLOCKSWITCH, 1); | ||
949 | } | ||
950 | static void switch_vt_done(_THIS) | ||
951 | { | ||
952 | SDL_Surface *screen = SDL_VideoSurface; | ||
953 | |||
954 | /* Restore graphics mode and the contents of the screen */ | ||
955 | ioctl(keyboard_fd, VT_LOCKSWITCH, 1); | ||
956 | ioctl(keyboard_fd, KDSETMODE, KD_GRAPHICS); | ||
957 | ioctl(console_fd, FBIOPUT_VSCREENINFO, &screen_vinfo); | ||
958 | FB_RestorePaletteFrom(this, 256, screen_palette); | ||
959 | if ( screen_contents ) { | ||
960 | SDL_memcpy(screen->pixels, screen_contents, screen_arealen); | ||
961 | SDL_free(screen_contents); | ||
962 | screen_contents = NULL; | ||
963 | } | ||
964 | |||
965 | /* Get updates to the shadow surface while switched away */ | ||
966 | if ( SDL_ShadowSurface ) { | ||
967 | SDL_UpdateRect(SDL_ShadowSurface, 0, 0, 0, 0); | ||
968 | } | ||
969 | |||
970 | SDL_PrivateAppActive(1, (SDL_APPACTIVE|SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS)); | ||
971 | } | ||
972 | static void switch_vt(_THIS, unsigned short which) | ||
973 | { | ||
974 | struct vt_stat vtstate; | ||
975 | |||
976 | /* Figure out whether or not we're switching to a new console */ | ||
977 | if ( (ioctl(keyboard_fd, VT_GETSTATE, &vtstate) < 0) || | ||
978 | (which == vtstate.v_active) ) { | ||
979 | return; | ||
980 | } | ||
981 | |||
982 | /* New console, switch to it */ | ||
983 | SDL_mutexP(hw_lock); | ||
984 | switch_vt_prep(this); | ||
985 | if ( ioctl(keyboard_fd, VT_ACTIVATE, which) == 0 ) { | ||
986 | ioctl(keyboard_fd, VT_WAITACTIVE, which); | ||
987 | switched_away = 1; | ||
988 | } else { | ||
989 | switch_vt_done(this); | ||
990 | } | ||
991 | SDL_mutexV(hw_lock); | ||
992 | } | ||
993 | |||
994 | static void handle_keyboard(_THIS) | ||
995 | { | ||
996 | unsigned char keybuf[BUFSIZ]; | ||
997 | int i, nread; | ||
998 | int pressed; | ||
999 | int scancode; | ||
1000 | SDL_keysym keysym; | ||
1001 | |||
1002 | nread = read(keyboard_fd, keybuf, BUFSIZ); | ||
1003 | for ( i=0; i<nread; ++i ) { | ||
1004 | scancode = keybuf[i] & 0x7F; | ||
1005 | if ( keybuf[i] & 0x80 ) { | ||
1006 | pressed = SDL_RELEASED; | ||
1007 | } else { | ||
1008 | pressed = SDL_PRESSED; | ||
1009 | } | ||
1010 | TranslateKey(scancode, &keysym); | ||
1011 | /* Handle Ctrl-Alt-FN for vt switch */ | ||
1012 | switch (keysym.sym) { | ||
1013 | case SDLK_F1: | ||
1014 | case SDLK_F2: | ||
1015 | case SDLK_F3: | ||
1016 | case SDLK_F4: | ||
1017 | case SDLK_F5: | ||
1018 | case SDLK_F6: | ||
1019 | case SDLK_F7: | ||
1020 | case SDLK_F8: | ||
1021 | case SDLK_F9: | ||
1022 | case SDLK_F10: | ||
1023 | case SDLK_F11: | ||
1024 | case SDLK_F12: | ||
1025 | if ( (SDL_GetModState() & KMOD_CTRL) && | ||
1026 | (SDL_GetModState() & KMOD_ALT) ) { | ||
1027 | if ( pressed ) { | ||
1028 | switch_vt(this, (keysym.sym-SDLK_F1)+1); | ||
1029 | } | ||
1030 | break; | ||
1031 | } | ||
1032 | /* Fall through to normal processing */ | ||
1033 | default: | ||
1034 | posted += SDL_PrivateKeyboard(pressed, &keysym); | ||
1035 | break; | ||
1036 | } | ||
1037 | } | ||
1038 | } | ||
1039 | |||
1040 | void FB_PumpEvents(_THIS) | ||
1041 | { | ||
1042 | fd_set fdset; | ||
1043 | int max_fd; | ||
1044 | static struct timeval zero; | ||
1045 | |||
1046 | do { | ||
1047 | if ( switched_away ) { | ||
1048 | struct vt_stat vtstate; | ||
1049 | |||
1050 | SDL_mutexP(hw_lock); | ||
1051 | if ( (ioctl(keyboard_fd, VT_GETSTATE, &vtstate) == 0) && | ||
1052 | vtstate.v_active == current_vt ) { | ||
1053 | switched_away = 0; | ||
1054 | switch_vt_done(this); | ||
1055 | } | ||
1056 | SDL_mutexV(hw_lock); | ||
1057 | } | ||
1058 | |||
1059 | posted = 0; | ||
1060 | |||
1061 | FD_ZERO(&fdset); | ||
1062 | max_fd = 0; | ||
1063 | if ( keyboard_fd >= 0 ) { | ||
1064 | FD_SET(keyboard_fd, &fdset); | ||
1065 | if ( max_fd < keyboard_fd ) { | ||
1066 | max_fd = keyboard_fd; | ||
1067 | } | ||
1068 | } | ||
1069 | if ( mouse_fd >= 0 ) { | ||
1070 | FD_SET(mouse_fd, &fdset); | ||
1071 | if ( max_fd < mouse_fd ) { | ||
1072 | max_fd = mouse_fd; | ||
1073 | } | ||
1074 | } | ||
1075 | if ( select(max_fd+1, &fdset, NULL, NULL, &zero) > 0 ) { | ||
1076 | if ( keyboard_fd >= 0 ) { | ||
1077 | if ( FD_ISSET(keyboard_fd, &fdset) ) { | ||
1078 | handle_keyboard(this); | ||
1079 | } | ||
1080 | } | ||
1081 | if ( mouse_fd >= 0 ) { | ||
1082 | if ( FD_ISSET(mouse_fd, &fdset) ) { | ||
1083 | handle_mouse(this); | ||
1084 | } | ||
1085 | } | ||
1086 | } | ||
1087 | } while ( posted ); | ||
1088 | } | ||
1089 | |||
1090 | void FB_InitOSKeymap(_THIS) | ||
1091 | { | ||
1092 | int i; | ||
1093 | |||
1094 | /* Initialize the Linux key translation table */ | ||
1095 | |||
1096 | /* First get the ascii keys and others not well handled */ | ||
1097 | for (i=0; i<SDL_arraysize(keymap); ++i) { | ||
1098 | switch(i) { | ||
1099 | /* These aren't handled by the x86 kernel keymapping (?) */ | ||
1100 | case SCANCODE_PRINTSCREEN: | ||
1101 | keymap[i] = SDLK_PRINT; | ||
1102 | break; | ||
1103 | case SCANCODE_BREAK: | ||
1104 | keymap[i] = SDLK_BREAK; | ||
1105 | break; | ||
1106 | case SCANCODE_BREAK_ALTERNATIVE: | ||
1107 | keymap[i] = SDLK_PAUSE; | ||
1108 | break; | ||
1109 | case SCANCODE_LEFTSHIFT: | ||
1110 | keymap[i] = SDLK_LSHIFT; | ||
1111 | break; | ||
1112 | case SCANCODE_RIGHTSHIFT: | ||
1113 | keymap[i] = SDLK_RSHIFT; | ||
1114 | break; | ||
1115 | case SCANCODE_LEFTCONTROL: | ||
1116 | keymap[i] = SDLK_LCTRL; | ||
1117 | break; | ||
1118 | case SCANCODE_RIGHTCONTROL: | ||
1119 | keymap[i] = SDLK_RCTRL; | ||
1120 | break; | ||
1121 | case SCANCODE_RIGHTWIN: | ||
1122 | keymap[i] = SDLK_RSUPER; | ||
1123 | break; | ||
1124 | case SCANCODE_LEFTWIN: | ||
1125 | keymap[i] = SDLK_LSUPER; | ||
1126 | break; | ||
1127 | case SCANCODE_LEFTALT: | ||
1128 | keymap[i] = SDLK_LALT; | ||
1129 | break; | ||
1130 | case SCANCODE_RIGHTALT: | ||
1131 | keymap[i] = SDLK_RALT; | ||
1132 | break; | ||
1133 | case 127: | ||
1134 | keymap[i] = SDLK_MENU; | ||
1135 | break; | ||
1136 | /* this should take care of all standard ascii keys */ | ||
1137 | default: | ||
1138 | keymap[i] = KVAL(vga_keymap[0][i]); | ||
1139 | break; | ||
1140 | } | ||
1141 | } | ||
1142 | for (i=0; i<SDL_arraysize(keymap); ++i) { | ||
1143 | switch(keymap_temp[i]) { | ||
1144 | case K_F1: keymap[i] = SDLK_F1; break; | ||
1145 | case K_F2: keymap[i] = SDLK_F2; break; | ||
1146 | case K_F3: keymap[i] = SDLK_F3; break; | ||
1147 | case K_F4: keymap[i] = SDLK_F4; break; | ||
1148 | case K_F5: keymap[i] = SDLK_F5; break; | ||
1149 | case K_F6: keymap[i] = SDLK_F6; break; | ||
1150 | case K_F7: keymap[i] = SDLK_F7; break; | ||
1151 | case K_F8: keymap[i] = SDLK_F8; break; | ||
1152 | case K_F9: keymap[i] = SDLK_F9; break; | ||
1153 | case K_F10: keymap[i] = SDLK_F10; break; | ||
1154 | case K_F11: keymap[i] = SDLK_F11; break; | ||
1155 | case K_F12: keymap[i] = SDLK_F12; break; | ||
1156 | |||
1157 | case K_DOWN: keymap[i] = SDLK_DOWN; break; | ||
1158 | case K_LEFT: keymap[i] = SDLK_LEFT; break; | ||
1159 | case K_RIGHT: keymap[i] = SDLK_RIGHT; break; | ||
1160 | case K_UP: keymap[i] = SDLK_UP; break; | ||
1161 | |||
1162 | case K_P0: keymap[i] = SDLK_KP0; break; | ||
1163 | case K_P1: keymap[i] = SDLK_KP1; break; | ||
1164 | case K_P2: keymap[i] = SDLK_KP2; break; | ||
1165 | case K_P3: keymap[i] = SDLK_KP3; break; | ||
1166 | case K_P4: keymap[i] = SDLK_KP4; break; | ||
1167 | case K_P5: keymap[i] = SDLK_KP5; break; | ||
1168 | case K_P6: keymap[i] = SDLK_KP6; break; | ||
1169 | case K_P7: keymap[i] = SDLK_KP7; break; | ||
1170 | case K_P8: keymap[i] = SDLK_KP8; break; | ||
1171 | case K_P9: keymap[i] = SDLK_KP9; break; | ||
1172 | case K_PPLUS: keymap[i] = SDLK_KP_PLUS; break; | ||
1173 | case K_PMINUS: keymap[i] = SDLK_KP_MINUS; break; | ||
1174 | case K_PSTAR: keymap[i] = SDLK_KP_MULTIPLY; break; | ||
1175 | case K_PSLASH: keymap[i] = SDLK_KP_DIVIDE; break; | ||
1176 | case K_PENTER: keymap[i] = SDLK_KP_ENTER; break; | ||
1177 | case K_PDOT: keymap[i] = SDLK_KP_PERIOD; break; | ||
1178 | |||
1179 | case K_SHIFT: if ( keymap[i] != SDLK_RSHIFT ) | ||
1180 | keymap[i] = SDLK_LSHIFT; | ||
1181 | break; | ||
1182 | case K_SHIFTL: keymap[i] = SDLK_LSHIFT; break; | ||
1183 | case K_SHIFTR: keymap[i] = SDLK_RSHIFT; break; | ||
1184 | case K_CTRL: if ( keymap[i] != SDLK_RCTRL ) | ||
1185 | keymap[i] = SDLK_LCTRL; | ||
1186 | break; | ||
1187 | case K_CTRLL: keymap[i] = SDLK_LCTRL; break; | ||
1188 | case K_CTRLR: keymap[i] = SDLK_RCTRL; break; | ||
1189 | case K_ALT: keymap[i] = SDLK_LALT; break; | ||
1190 | case K_ALTGR: keymap[i] = SDLK_RALT; break; | ||
1191 | |||
1192 | case K_INSERT: keymap[i] = SDLK_INSERT; break; | ||
1193 | case K_REMOVE: keymap[i] = SDLK_DELETE; break; | ||
1194 | case K_PGUP: keymap[i] = SDLK_PAGEUP; break; | ||
1195 | case K_PGDN: keymap[i] = SDLK_PAGEDOWN; break; | ||
1196 | case K_FIND: keymap[i] = SDLK_HOME; break; | ||
1197 | case K_SELECT: keymap[i] = SDLK_END; break; | ||
1198 | |||
1199 | case K_NUM: keymap[i] = SDLK_NUMLOCK; break; | ||
1200 | case K_CAPS: keymap[i] = SDLK_CAPSLOCK; break; | ||
1201 | |||
1202 | case K_F13: keymap[i] = SDLK_PRINT; break; | ||
1203 | case K_HOLD: keymap[i] = SDLK_SCROLLOCK; break; | ||
1204 | case K_PAUSE: keymap[i] = SDLK_PAUSE; break; | ||
1205 | |||
1206 | case 127: keymap[i] = SDLK_BACKSPACE; break; | ||
1207 | |||
1208 | default: break; | ||
1209 | } | ||
1210 | } | ||
1211 | } | ||
1212 | |||
1213 | static SDL_keysym *TranslateKey(int scancode, SDL_keysym *keysym) | ||
1214 | { | ||
1215 | /* Set the keysym information */ | ||
1216 | keysym->scancode = scancode; | ||
1217 | keysym->sym = keymap[scancode]; | ||
1218 | keysym->mod = KMOD_NONE; | ||
1219 | |||
1220 | /* If UNICODE is on, get the UNICODE value for the key */ | ||
1221 | keysym->unicode = 0; | ||
1222 | if ( SDL_TranslateUNICODE ) { | ||
1223 | int map; | ||
1224 | SDLMod modstate; | ||
1225 | |||
1226 | modstate = SDL_GetModState(); | ||
1227 | map = 0; | ||
1228 | if ( modstate & KMOD_SHIFT ) { | ||
1229 | map |= (1<<KG_SHIFT); | ||
1230 | } | ||
1231 | if ( modstate & KMOD_CTRL ) { | ||
1232 | map |= (1<<KG_CTRL); | ||
1233 | } | ||
1234 | if ( modstate & KMOD_LALT ) { | ||
1235 | map |= (1<<KG_ALT); | ||
1236 | } | ||
1237 | if ( modstate & KMOD_RALT ) { | ||
1238 | map |= (1<<KG_ALTGR); | ||
1239 | } | ||
1240 | if ( KTYP(vga_keymap[map][scancode]) == KT_LETTER ) { | ||
1241 | if ( modstate & KMOD_CAPS ) { | ||
1242 | map ^= (1<<KG_SHIFT); | ||
1243 | } | ||
1244 | } | ||
1245 | if ( KTYP(vga_keymap[map][scancode]) == KT_PAD ) { | ||
1246 | if ( modstate & KMOD_NUM ) { | ||
1247 | keysym->unicode=KVAL(vga_keymap[map][scancode]); | ||
1248 | } | ||
1249 | } else { | ||
1250 | keysym->unicode = KVAL(vga_keymap[map][scancode]); | ||
1251 | } | ||
1252 | } | ||
1253 | return(keysym); | ||
1254 | } | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbevents_c.h b/apps/plugins/sdl/src/video/fbcon/SDL_fbevents_c.h deleted file mode 100644 index fe8b09cab3..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbevents_c.h +++ /dev/null | |||
@@ -1,38 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_fbvideo.h" | ||
25 | |||
26 | /* Variables and functions exported by SDL_sysevents.c to other parts | ||
27 | of the native video subsystem (SDL_sysvideo.c) | ||
28 | */ | ||
29 | extern int FB_OpenKeyboard(_THIS); | ||
30 | extern void FB_CloseKeyboard(_THIS); | ||
31 | extern int FB_OpenMouse(_THIS); | ||
32 | extern void FB_CloseMouse(_THIS); | ||
33 | extern int FB_EnterGraphicsMode(_THIS); | ||
34 | extern int FB_InGraphicsMode(_THIS); | ||
35 | extern void FB_LeaveGraphicsMode(_THIS); | ||
36 | |||
37 | extern void FB_InitOSKeymap(_THIS); | ||
38 | extern void FB_PumpEvents(_THIS); | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbkeys.h b/apps/plugins/sdl/src/video/fbcon/SDL_fbkeys.h deleted file mode 100644 index 2b01b6b2e3..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbkeys.h +++ /dev/null | |||
@@ -1,139 +0,0 @@ | |||
1 | |||
2 | /* Scancodes for the Linux framebuffer console | ||
3 | - Taken with thanks from SVGAlib 1.4.0 | ||
4 | */ | ||
5 | |||
6 | #define SCANCODE_ESCAPE 1 | ||
7 | |||
8 | #define SCANCODE_1 2 | ||
9 | #define SCANCODE_2 3 | ||
10 | #define SCANCODE_3 4 | ||
11 | #define SCANCODE_4 5 | ||
12 | #define SCANCODE_5 6 | ||
13 | #define SCANCODE_6 7 | ||
14 | #define SCANCODE_7 8 | ||
15 | #define SCANCODE_8 9 | ||
16 | #define SCANCODE_9 10 | ||
17 | #define SCANCODE_0 11 | ||
18 | |||
19 | #define SCANCODE_MINUS 12 | ||
20 | #define SCANCODE_EQUAL 13 | ||
21 | |||
22 | #define SCANCODE_BACKSPACE 14 | ||
23 | #define SCANCODE_TAB 15 | ||
24 | |||
25 | #define SCANCODE_Q 16 | ||
26 | #define SCANCODE_W 17 | ||
27 | #define SCANCODE_E 18 | ||
28 | #define SCANCODE_R 19 | ||
29 | #define SCANCODE_T 20 | ||
30 | #define SCANCODE_Y 21 | ||
31 | #define SCANCODE_U 22 | ||
32 | #define SCANCODE_I 23 | ||
33 | #define SCANCODE_O 24 | ||
34 | #define SCANCODE_P 25 | ||
35 | #define SCANCODE_BRACKET_LEFT 26 | ||
36 | #define SCANCODE_BRACKET_RIGHT 27 | ||
37 | |||
38 | #define SCANCODE_ENTER 28 | ||
39 | |||
40 | #define SCANCODE_LEFTCONTROL 29 | ||
41 | |||
42 | #define SCANCODE_A 30 | ||
43 | #define SCANCODE_S 31 | ||
44 | #define SCANCODE_D 32 | ||
45 | #define SCANCODE_F 33 | ||
46 | #define SCANCODE_G 34 | ||
47 | #define SCANCODE_H 35 | ||
48 | #define SCANCODE_J 36 | ||
49 | #define SCANCODE_K 37 | ||
50 | #define SCANCODE_L 38 | ||
51 | #define SCANCODE_SEMICOLON 39 | ||
52 | #define SCANCODE_APOSTROPHE 40 | ||
53 | #define SCANCODE_GRAVE 41 | ||
54 | |||
55 | #define SCANCODE_LEFTSHIFT 42 | ||
56 | #define SCANCODE_BACKSLASH 43 | ||
57 | |||
58 | #define SCANCODE_Z 44 | ||
59 | #define SCANCODE_X 45 | ||
60 | #define SCANCODE_C 46 | ||
61 | #define SCANCODE_V 47 | ||
62 | #define SCANCODE_B 48 | ||
63 | #define SCANCODE_N 49 | ||
64 | #define SCANCODE_M 50 | ||
65 | #define SCANCODE_COMMA 51 | ||
66 | #define SCANCODE_PERIOD 52 | ||
67 | #define SCANCODE_SLASH 53 | ||
68 | |||
69 | #define SCANCODE_RIGHTSHIFT 54 | ||
70 | #define SCANCODE_KEYPADMULTIPLY 55 | ||
71 | |||
72 | #define SCANCODE_LEFTALT 56 | ||
73 | #define SCANCODE_SPACE 57 | ||
74 | #define SCANCODE_CAPSLOCK 58 | ||
75 | |||
76 | #define SCANCODE_F1 59 | ||
77 | #define SCANCODE_F2 60 | ||
78 | #define SCANCODE_F3 61 | ||
79 | #define SCANCODE_F4 62 | ||
80 | #define SCANCODE_F5 63 | ||
81 | #define SCANCODE_F6 64 | ||
82 | #define SCANCODE_F7 65 | ||
83 | #define SCANCODE_F8 66 | ||
84 | #define SCANCODE_F9 67 | ||
85 | #define SCANCODE_F10 68 | ||
86 | |||
87 | #define SCANCODE_NUMLOCK 69 | ||
88 | #define SCANCODE_SCROLLLOCK 70 | ||
89 | |||
90 | #define SCANCODE_KEYPAD7 71 | ||
91 | #define SCANCODE_CURSORUPLEFT 71 | ||
92 | #define SCANCODE_KEYPAD8 72 | ||
93 | #define SCANCODE_CURSORUP 72 | ||
94 | #define SCANCODE_KEYPAD9 73 | ||
95 | #define SCANCODE_CURSORUPRIGHT 73 | ||
96 | #define SCANCODE_KEYPADMINUS 74 | ||
97 | #define SCANCODE_KEYPAD4 75 | ||
98 | #define SCANCODE_CURSORLEFT 75 | ||
99 | #define SCANCODE_KEYPAD5 76 | ||
100 | #define SCANCODE_KEYPAD6 77 | ||
101 | #define SCANCODE_CURSORRIGHT 77 | ||
102 | #define SCANCODE_KEYPADPLUS 78 | ||
103 | #define SCANCODE_KEYPAD1 79 | ||
104 | #define SCANCODE_CURSORDOWNLEFT 79 | ||
105 | #define SCANCODE_KEYPAD2 80 | ||
106 | #define SCANCODE_CURSORDOWN 80 | ||
107 | #define SCANCODE_KEYPAD3 81 | ||
108 | #define SCANCODE_CURSORDOWNRIGHT 81 | ||
109 | #define SCANCODE_KEYPAD0 82 | ||
110 | #define SCANCODE_KEYPADPERIOD 83 | ||
111 | |||
112 | #define SCANCODE_LESS 86 | ||
113 | |||
114 | #define SCANCODE_F11 87 | ||
115 | #define SCANCODE_F12 88 | ||
116 | |||
117 | #define SCANCODE_KEYPADENTER 96 | ||
118 | #define SCANCODE_RIGHTCONTROL 97 | ||
119 | #define SCANCODE_CONTROL 97 | ||
120 | #define SCANCODE_KEYPADDIVIDE 98 | ||
121 | #define SCANCODE_PRINTSCREEN 99 | ||
122 | #define SCANCODE_RIGHTALT 100 | ||
123 | #define SCANCODE_BREAK 101 /* Beware: is 119 */ | ||
124 | #define SCANCODE_BREAK_ALTERNATIVE 119 /* on some keyboards! */ | ||
125 | |||
126 | #define SCANCODE_HOME 102 | ||
127 | #define SCANCODE_CURSORBLOCKUP 103 /* Cursor key block */ | ||
128 | #define SCANCODE_PAGEUP 104 | ||
129 | #define SCANCODE_CURSORBLOCKLEFT 105 /* Cursor key block */ | ||
130 | #define SCANCODE_CURSORBLOCKRIGHT 106 /* Cursor key block */ | ||
131 | #define SCANCODE_END 107 | ||
132 | #define SCANCODE_CURSORBLOCKDOWN 108 /* Cursor key block */ | ||
133 | #define SCANCODE_PAGEDOWN 109 | ||
134 | #define SCANCODE_INSERT 110 | ||
135 | #define SCANCODE_REMOVE 111 | ||
136 | |||
137 | #define SCANCODE_RIGHTWIN 126 | ||
138 | #define SCANCODE_LEFTWIN 125 | ||
139 | |||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbmatrox.c b/apps/plugins/sdl/src/video/fbcon/SDL_fbmatrox.c deleted file mode 100644 index 04b90b05da..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbmatrox.c +++ /dev/null | |||
@@ -1,280 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_video.h" | ||
25 | #include "../SDL_blit.h" | ||
26 | #include "SDL_fbmatrox.h" | ||
27 | #include "matrox_mmio.h" | ||
28 | |||
29 | |||
30 | /* Wait for vertical retrace - taken from the XFree86 Matrox driver */ | ||
31 | static void WaitVBL(_THIS) | ||
32 | { | ||
33 | int count; | ||
34 | |||
35 | /* find start of retrace */ | ||
36 | mga_waitidle(); | ||
37 | while ( (mga_in8(0x1FDA) & 0x08) ) | ||
38 | ; | ||
39 | while ( !(mga_in8(0x1FDA) & 0x08) ) | ||
40 | ; | ||
41 | /* wait until we're past the start */ | ||
42 | count = mga_in32(0x1E20) + 2; | ||
43 | while ( mga_in32(0x1E20) < count ) | ||
44 | ; | ||
45 | } | ||
46 | static void WaitIdle(_THIS) | ||
47 | { | ||
48 | mga_waitidle(); | ||
49 | } | ||
50 | |||
51 | /* Sets video mem colorkey and accelerated blit function */ | ||
52 | static int SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) | ||
53 | { | ||
54 | return(0); | ||
55 | } | ||
56 | |||
57 | /* Sets per surface hardware alpha value */ | ||
58 | #if 0 | ||
59 | static int SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 value) | ||
60 | { | ||
61 | return(0); | ||
62 | } | ||
63 | #endif | ||
64 | |||
65 | static int FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color) | ||
66 | { | ||
67 | int dstX, dstY; | ||
68 | Uint32 fxbndry; | ||
69 | Uint32 ydstlen; | ||
70 | Uint32 fillop; | ||
71 | |||
72 | /* Don't blit to the display surface when switched away */ | ||
73 | if ( switched_away ) { | ||
74 | return -2; /* no hardware access */ | ||
75 | } | ||
76 | if ( dst == this->screen ) { | ||
77 | SDL_mutexP(hw_lock); | ||
78 | } | ||
79 | |||
80 | switch (dst->format->BytesPerPixel) { | ||
81 | case 1: | ||
82 | color |= (color<<8); | ||
83 | case 2: | ||
84 | color |= (color<<16); | ||
85 | break; | ||
86 | } | ||
87 | |||
88 | /* Set up the X/Y base coordinates */ | ||
89 | FB_dst_to_xy(this, dst, &dstX, &dstY); | ||
90 | |||
91 | /* Adjust for the current rectangle */ | ||
92 | dstX += rect->x; | ||
93 | dstY += rect->y; | ||
94 | |||
95 | /* Set up the X boundaries */ | ||
96 | fxbndry = (dstX | ((dstX+rect->w) << 16)); | ||
97 | |||
98 | /* Set up the Y boundaries */ | ||
99 | ydstlen = (rect->h | (dstY << 16)); | ||
100 | |||
101 | /* Set up for color fill operation */ | ||
102 | fillop = MGADWG_TRAP | MGADWG_SOLID | | ||
103 | MGADWG_ARZERO | MGADWG_SGNZERO | MGADWG_SHIFTZERO; | ||
104 | |||
105 | /* Execute the operations! */ | ||
106 | mga_wait(5); | ||
107 | mga_out32(MGAREG_DWGCTL, fillop | MGADWG_REPLACE); | ||
108 | mga_out32(MGAREG_FCOL, color); | ||
109 | mga_out32(MGAREG_FXBNDRY, fxbndry); | ||
110 | mga_out32(MGAREG_YDSTLEN + MGAREG_EXEC, ydstlen); | ||
111 | |||
112 | FB_AddBusySurface(dst); | ||
113 | |||
114 | if ( dst == this->screen ) { | ||
115 | SDL_mutexV(hw_lock); | ||
116 | } | ||
117 | return(0); | ||
118 | } | ||
119 | |||
120 | static int HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | ||
121 | SDL_Surface *dst, SDL_Rect *dstrect) | ||
122 | { | ||
123 | SDL_VideoDevice *this = current_video; | ||
124 | int pitch, w, h; | ||
125 | int srcX, srcY; | ||
126 | int dstX, dstY; | ||
127 | Uint32 sign; | ||
128 | Uint32 start, stop; | ||
129 | int skip; | ||
130 | Uint32 blitop; | ||
131 | |||
132 | /* FIXME: For now, only blit to display surface */ | ||
133 | if ( dst->pitch != SDL_VideoSurface->pitch ) { | ||
134 | return(src->map->sw_blit(src, srcrect, dst, dstrect)); | ||
135 | } | ||
136 | |||
137 | /* Don't blit to the display surface when switched away */ | ||
138 | if ( switched_away ) { | ||
139 | return -2; /* no hardware access */ | ||
140 | } | ||
141 | if ( dst == this->screen ) { | ||
142 | SDL_mutexP(hw_lock); | ||
143 | } | ||
144 | |||
145 | /* Calculate source and destination base coordinates (in pixels) */ | ||
146 | w = dstrect->w; | ||
147 | h = dstrect->h; | ||
148 | FB_dst_to_xy(this, src, &srcX, &srcY); | ||
149 | FB_dst_to_xy(this, dst, &dstX, &dstY); | ||
150 | |||
151 | /* Adjust for the current blit rectangles */ | ||
152 | srcX += srcrect->x; | ||
153 | srcY += srcrect->y; | ||
154 | dstX += dstrect->x; | ||
155 | dstY += dstrect->y; | ||
156 | pitch = dst->pitch/dst->format->BytesPerPixel; | ||
157 | |||
158 | /* Set up the blit direction (sign) flags */ | ||
159 | sign = 0; | ||
160 | if ( srcX < dstX ) { | ||
161 | sign |= 1; | ||
162 | } | ||
163 | if ( srcY < dstY ) { | ||
164 | sign |= 4; | ||
165 | srcY += (h - 1); | ||
166 | dstY += (h - 1); | ||
167 | } | ||
168 | |||
169 | /* Set up the blit source row start, end, and skip (in pixels) */ | ||
170 | stop = start = (srcY * pitch) + srcX; | ||
171 | if ( srcX < dstX ) { | ||
172 | start += (w - 1); | ||
173 | } else { | ||
174 | stop += (w - 1); | ||
175 | } | ||
176 | if ( srcY < dstY ) { | ||
177 | skip = -pitch; | ||
178 | } else { | ||
179 | skip = pitch; | ||
180 | } | ||
181 | |||
182 | /* Set up the blit operation */ | ||
183 | if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | ||
184 | Uint32 colorkey; | ||
185 | |||
186 | blitop = MGADWG_BFCOL | MGADWG_BITBLT | | ||
187 | MGADWG_SHIFTZERO | MGADWG_RSTR | (0x0C << 16) | | ||
188 | MGADWG_TRANSC; | ||
189 | |||
190 | colorkey = src->format->colorkey; | ||
191 | switch (dst->format->BytesPerPixel) { | ||
192 | case 1: | ||
193 | colorkey |= (colorkey<<8); | ||
194 | case 2: | ||
195 | colorkey |= (colorkey<<16); | ||
196 | break; | ||
197 | } | ||
198 | mga_wait(2); | ||
199 | mga_out32(MGAREG_FCOL, colorkey); | ||
200 | mga_out32(MGAREG_BCOL, 0xFFFFFFFF); | ||
201 | } else { | ||
202 | blitop = MGADWG_BFCOL | MGADWG_BITBLT | | ||
203 | MGADWG_SHIFTZERO | MGADWG_RSTR | (0x0C << 16); | ||
204 | } | ||
205 | mga_wait(7); | ||
206 | mga_out32(MGAREG_SGN, sign); | ||
207 | mga_out32(MGAREG_AR3, start); | ||
208 | mga_out32(MGAREG_AR0, stop); | ||
209 | mga_out32(MGAREG_AR5, skip); | ||
210 | mga_out32(MGAREG_FXBNDRY, (dstX | ((dstX + w-1) << 16))); | ||
211 | mga_out32(MGAREG_YDSTLEN, (dstY << 16) | h); | ||
212 | mga_out32(MGAREG_DWGCTL + MGAREG_EXEC, blitop); | ||
213 | |||
214 | FB_AddBusySurface(src); | ||
215 | FB_AddBusySurface(dst); | ||
216 | |||
217 | if ( dst == this->screen ) { | ||
218 | SDL_mutexV(hw_lock); | ||
219 | } | ||
220 | return(0); | ||
221 | } | ||
222 | |||
223 | static int CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst) | ||
224 | { | ||
225 | int accelerated; | ||
226 | |||
227 | /* Set initial acceleration on */ | ||
228 | src->flags |= SDL_HWACCEL; | ||
229 | |||
230 | /* Set the surface attributes */ | ||
231 | if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { | ||
232 | if ( ! this->info.blit_hw_A ) { | ||
233 | src->flags &= ~SDL_HWACCEL; | ||
234 | } | ||
235 | } | ||
236 | if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | ||
237 | if ( ! this->info.blit_hw_CC ) { | ||
238 | src->flags &= ~SDL_HWACCEL; | ||
239 | } | ||
240 | } | ||
241 | |||
242 | /* Check to see if final surface blit is accelerated */ | ||
243 | accelerated = !!(src->flags & SDL_HWACCEL); | ||
244 | if ( accelerated ) { | ||
245 | src->map->hw_blit = HWAccelBlit; | ||
246 | } | ||
247 | return(accelerated); | ||
248 | } | ||
249 | |||
250 | void FB_MatroxAccel(_THIS, __u32 card) | ||
251 | { | ||
252 | /* We have hardware accelerated surface functions */ | ||
253 | this->CheckHWBlit = CheckHWBlit; | ||
254 | wait_vbl = WaitVBL; | ||
255 | wait_idle = WaitIdle; | ||
256 | |||
257 | /* The Matrox has an accelerated color fill */ | ||
258 | this->info.blit_fill = 1; | ||
259 | this->FillHWRect = FillHWRect; | ||
260 | |||
261 | /* The Matrox has accelerated normal and colorkey blits. */ | ||
262 | this->info.blit_hw = 1; | ||
263 | /* The Millenium I appears to do the colorkey test a word | ||
264 | at a time, and the transparency is intverted. (?) | ||
265 | */ | ||
266 | if ( card != FB_ACCEL_MATROX_MGA2064W ) { | ||
267 | this->info.blit_hw_CC = 1; | ||
268 | this->SetHWColorKey = SetHWColorKey; | ||
269 | } | ||
270 | |||
271 | #if 0 /* Not yet implemented? */ | ||
272 | /* The Matrox G200/G400 has an accelerated alpha blit */ | ||
273 | if ( (card == FB_ACCEL_MATROX_MGAG200) | ||
274 | || (card == FB_ACCEL_MATROX_MGAG400) | ||
275 | ) { | ||
276 | this->info.blit_hw_A = 1; | ||
277 | this->SetHWAlpha = SetHWAlpha; | ||
278 | } | ||
279 | #endif | ||
280 | } | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbmatrox.h b/apps/plugins/sdl/src/video/fbcon/SDL_fbmatrox.h deleted file mode 100644 index f7d41b0240..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbmatrox.h +++ /dev/null | |||
@@ -1,29 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* Matrox hardware acceleration for the SDL framebuffer console driver */ | ||
25 | |||
26 | #include "SDL_fbvideo.h" | ||
27 | |||
28 | /* Set up the driver for Matrox acceleration */ | ||
29 | extern void FB_MatroxAccel(_THIS, __u32 card); | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbmouse.c b/apps/plugins/sdl/src/video/fbcon/SDL_fbmouse.c deleted file mode 100644 index d65f27ece5..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbmouse.c +++ /dev/null | |||
@@ -1,33 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_mouse.h" | ||
25 | #include "../../events/SDL_events_c.h" | ||
26 | #include "SDL_fbvideo.h" | ||
27 | #include "SDL_fbmouse_c.h" | ||
28 | |||
29 | |||
30 | /* The implementation dependent data for the window manager cursor */ | ||
31 | struct WMcursor { | ||
32 | int unused; | ||
33 | }; | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbmouse_c.h b/apps/plugins/sdl/src/video/fbcon/SDL_fbmouse_c.h deleted file mode 100644 index fbb031d1f7..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbmouse_c.h +++ /dev/null | |||
@@ -1,26 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_fbvideo.h" | ||
25 | |||
26 | /* Functions to be exported */ | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbriva.c b/apps/plugins/sdl/src/video/fbcon/SDL_fbriva.c deleted file mode 100644 index eb4b71f1bb..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbriva.c +++ /dev/null | |||
@@ -1,222 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_video.h" | ||
25 | #include "../SDL_blit.h" | ||
26 | #include "SDL_fbriva.h" | ||
27 | #include "riva_mmio.h" | ||
28 | #include "riva_regs.h" | ||
29 | |||
30 | |||
31 | static int FifoEmptyCount = 0; | ||
32 | static int FifoFreeCount = 0; | ||
33 | |||
34 | /* Wait for vertical retrace */ | ||
35 | static void WaitVBL(_THIS) | ||
36 | { | ||
37 | volatile Uint8 *port = (Uint8 *)(mapped_io + PCIO_OFFSET + 0x3DA); | ||
38 | |||
39 | while ( (*port & 0x08) ) | ||
40 | ; | ||
41 | while ( !(*port & 0x08) ) | ||
42 | ; | ||
43 | } | ||
44 | static void NV3WaitIdle(_THIS) | ||
45 | { | ||
46 | RivaRop *Rop = (RivaRop *)(mapped_io + ROP_OFFSET); | ||
47 | while ( (Rop->FifoFree < FifoEmptyCount) || | ||
48 | (*(mapped_io + PGRAPH_OFFSET + 0x000006B0) & 0x01) ) | ||
49 | ; | ||
50 | } | ||
51 | static void NV4WaitIdle(_THIS) | ||
52 | { | ||
53 | RivaRop *Rop = (RivaRop *)(mapped_io + ROP_OFFSET); | ||
54 | while ( (Rop->FifoFree < FifoEmptyCount) || | ||
55 | (*(mapped_io + PGRAPH_OFFSET + 0x00000700) & 0x01) ) | ||
56 | ; | ||
57 | } | ||
58 | |||
59 | #if 0 /* Not yet implemented? */ | ||
60 | /* Sets video mem colorkey and accelerated blit function */ | ||
61 | static int SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) | ||
62 | { | ||
63 | return(0); | ||
64 | } | ||
65 | |||
66 | /* Sets per surface hardware alpha value */ | ||
67 | static int SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 value) | ||
68 | { | ||
69 | return(0); | ||
70 | } | ||
71 | #endif /* Not yet implemented */ | ||
72 | |||
73 | static int FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color) | ||
74 | { | ||
75 | int dstX, dstY; | ||
76 | int dstW, dstH; | ||
77 | RivaBitmap *Bitmap = (RivaBitmap *)(mapped_io + BITMAP_OFFSET); | ||
78 | |||
79 | /* Don't blit to the display surface when switched away */ | ||
80 | if ( switched_away ) { | ||
81 | return -2; /* no hardware access */ | ||
82 | } | ||
83 | if ( dst == this->screen ) { | ||
84 | SDL_mutexP(hw_lock); | ||
85 | } | ||
86 | |||
87 | /* Set up the X/Y base coordinates */ | ||
88 | dstW = rect->w; | ||
89 | dstH = rect->h; | ||
90 | FB_dst_to_xy(this, dst, &dstX, &dstY); | ||
91 | |||
92 | /* Adjust for the current rectangle */ | ||
93 | dstX += rect->x; | ||
94 | dstY += rect->y; | ||
95 | |||
96 | RIVA_FIFO_FREE(Bitmap, 1); | ||
97 | Bitmap->Color1A = color; | ||
98 | |||
99 | RIVA_FIFO_FREE(Bitmap, 2); | ||
100 | Bitmap->UnclippedRectangle[0].TopLeft = (dstX << 16) | dstY; | ||
101 | Bitmap->UnclippedRectangle[0].WidthHeight = (dstW << 16) | dstH; | ||
102 | |||
103 | FB_AddBusySurface(dst); | ||
104 | |||
105 | if ( dst == this->screen ) { | ||
106 | SDL_mutexV(hw_lock); | ||
107 | } | ||
108 | return(0); | ||
109 | } | ||
110 | |||
111 | static int HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | ||
112 | SDL_Surface *dst, SDL_Rect *dstrect) | ||
113 | { | ||
114 | SDL_VideoDevice *this = current_video; | ||
115 | int srcX, srcY; | ||
116 | int dstX, dstY; | ||
117 | int dstW, dstH; | ||
118 | RivaScreenBlt *Blt = (RivaScreenBlt *)(mapped_io + BLT_OFFSET); | ||
119 | |||
120 | /* FIXME: For now, only blit to display surface */ | ||
121 | if ( dst->pitch != SDL_VideoSurface->pitch ) { | ||
122 | return(src->map->sw_blit(src, srcrect, dst, dstrect)); | ||
123 | } | ||
124 | |||
125 | /* Don't blit to the display surface when switched away */ | ||
126 | if ( switched_away ) { | ||
127 | return -2; /* no hardware access */ | ||
128 | } | ||
129 | if ( dst == this->screen ) { | ||
130 | SDL_mutexP(hw_lock); | ||
131 | } | ||
132 | |||
133 | /* Calculate source and destination base coordinates (in pixels) */ | ||
134 | dstW = dstrect->w; | ||
135 | dstH = dstrect->h; | ||
136 | FB_dst_to_xy(this, src, &srcX, &srcY); | ||
137 | FB_dst_to_xy(this, dst, &dstX, &dstY); | ||
138 | |||
139 | /* Adjust for the current blit rectangles */ | ||
140 | srcX += srcrect->x; | ||
141 | srcY += srcrect->y; | ||
142 | dstX += dstrect->x; | ||
143 | dstY += dstrect->y; | ||
144 | |||
145 | RIVA_FIFO_FREE(Blt, 3); | ||
146 | Blt->TopLeftSrc = (srcY << 16) | srcX; | ||
147 | Blt->TopLeftDst = (dstY << 16) | dstX; | ||
148 | Blt->WidthHeight = (dstH << 16) | dstW; | ||
149 | |||
150 | FB_AddBusySurface(src); | ||
151 | FB_AddBusySurface(dst); | ||
152 | |||
153 | if ( dst == this->screen ) { | ||
154 | SDL_mutexV(hw_lock); | ||
155 | } | ||
156 | return(0); | ||
157 | } | ||
158 | |||
159 | static int CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst) | ||
160 | { | ||
161 | int accelerated; | ||
162 | |||
163 | /* Set initial acceleration on */ | ||
164 | src->flags |= SDL_HWACCEL; | ||
165 | |||
166 | /* Set the surface attributes */ | ||
167 | if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { | ||
168 | if ( ! this->info.blit_hw_A ) { | ||
169 | src->flags &= ~SDL_HWACCEL; | ||
170 | } | ||
171 | } | ||
172 | if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | ||
173 | if ( ! this->info.blit_hw_CC ) { | ||
174 | src->flags &= ~SDL_HWACCEL; | ||
175 | } | ||
176 | } | ||
177 | |||
178 | /* Check to see if final surface blit is accelerated */ | ||
179 | accelerated = !!(src->flags & SDL_HWACCEL); | ||
180 | if ( accelerated ) { | ||
181 | src->map->hw_blit = HWAccelBlit; | ||
182 | } | ||
183 | return(accelerated); | ||
184 | } | ||
185 | |||
186 | void FB_RivaAccel(_THIS, __u32 card) | ||
187 | { | ||
188 | RivaRop *Rop = (RivaRop *)(mapped_io + ROP_OFFSET); | ||
189 | |||
190 | /* We have hardware accelerated surface functions */ | ||
191 | this->CheckHWBlit = CheckHWBlit; | ||
192 | wait_vbl = WaitVBL; | ||
193 | switch (card) { | ||
194 | case FB_ACCEL_NV3: | ||
195 | wait_idle = NV3WaitIdle; | ||
196 | break; | ||
197 | case FB_ACCEL_NV4: | ||
198 | wait_idle = NV4WaitIdle; | ||
199 | break; | ||
200 | default: | ||
201 | /* Hmm... FIXME */ | ||
202 | break; | ||
203 | } | ||
204 | FifoEmptyCount = Rop->FifoFree; | ||
205 | |||
206 | /* The Riva has an accelerated color fill */ | ||
207 | this->info.blit_fill = 1; | ||
208 | this->FillHWRect = FillHWRect; | ||
209 | |||
210 | /* The Riva has accelerated normal and colorkey blits. */ | ||
211 | this->info.blit_hw = 1; | ||
212 | #if 0 /* Not yet implemented? */ | ||
213 | this->info.blit_hw_CC = 1; | ||
214 | this->SetHWColorKey = SetHWColorKey; | ||
215 | #endif | ||
216 | |||
217 | #if 0 /* Not yet implemented? */ | ||
218 | /* The Riva has an accelerated alpha blit */ | ||
219 | this->info.blit_hw_A = 1; | ||
220 | this->SetHWAlpha = SetHWAlpha; | ||
221 | #endif | ||
222 | } | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbriva.h b/apps/plugins/sdl/src/video/fbcon/SDL_fbriva.h deleted file mode 100644 index c78682e8a5..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbriva.h +++ /dev/null | |||
@@ -1,36 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* Riva hardware acceleration for the SDL framebuffer console driver */ | ||
25 | |||
26 | #include "SDL_fbvideo.h" | ||
27 | |||
28 | #ifndef FB_ACCEL_NV3 | ||
29 | #define FB_ACCEL_NV3 27 | ||
30 | #endif | ||
31 | #ifndef FB_ACCEL_NV4 | ||
32 | #define FB_ACCEL_NV4 28 | ||
33 | #endif | ||
34 | |||
35 | /* Set up the driver for Riva acceleration */ | ||
36 | extern void FB_RivaAccel(_THIS, __u32 card); | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbvideo.c b/apps/plugins/sdl/src/video/fbcon/SDL_fbvideo.c deleted file mode 100644 index 5e5880908d..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbvideo.c +++ /dev/null | |||
@@ -1,1982 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* Framebuffer console based SDL video driver implementation. | ||
25 | */ | ||
26 | |||
27 | #include <stdio.h> | ||
28 | #include <fcntl.h> | ||
29 | #include <unistd.h> | ||
30 | #include <sys/ioctl.h> | ||
31 | #include <sys/mman.h> | ||
32 | |||
33 | #ifndef HAVE_GETPAGESIZE | ||
34 | #include <asm/page.h> /* For definition of PAGE_SIZE */ | ||
35 | #endif | ||
36 | |||
37 | #include <linux/vt.h> | ||
38 | |||
39 | #include "SDL_video.h" | ||
40 | #include "SDL_mouse.h" | ||
41 | #include "../SDL_sysvideo.h" | ||
42 | #include "../SDL_pixels_c.h" | ||
43 | #include "../../events/SDL_events_c.h" | ||
44 | #include "SDL_fbvideo.h" | ||
45 | #include "SDL_fbmouse_c.h" | ||
46 | #include "SDL_fbevents_c.h" | ||
47 | #include "SDL_fb3dfx.h" | ||
48 | #include "SDL_fbmatrox.h" | ||
49 | #include "SDL_fbriva.h" | ||
50 | |||
51 | /*#define FBCON_DEBUG*/ | ||
52 | |||
53 | #if defined(i386) && defined(FB_TYPE_VGA_PLANES) | ||
54 | #define VGA16_FBCON_SUPPORT | ||
55 | #include <sys/io.h> /* For ioperm() */ | ||
56 | #ifndef FB_AUX_VGA_PLANES_VGA4 | ||
57 | #define FB_AUX_VGA_PLANES_VGA4 0 | ||
58 | #endif | ||
59 | /* | ||
60 | static inline void outb (unsigned char value, unsigned short port) | ||
61 | { | ||
62 | __asm__ __volatile__ ("outb %b0,%w1"::"a" (value), "Nd" (port)); | ||
63 | } | ||
64 | */ | ||
65 | #endif /* FB_TYPE_VGA_PLANES */ | ||
66 | |||
67 | /* A list of video resolutions that we query for (sorted largest to smallest) */ | ||
68 | static const SDL_Rect checkres[] = { | ||
69 | { 0, 0, 1600, 1200 }, /* 16 bpp: 0x11E, or 286 */ | ||
70 | { 0, 0, 1408, 1056 }, /* 16 bpp: 0x19A, or 410 */ | ||
71 | { 0, 0, 1280, 1024 }, /* 16 bpp: 0x11A, or 282 */ | ||
72 | { 0, 0, 1152, 864 }, /* 16 bpp: 0x192, or 402 */ | ||
73 | { 0, 0, 1024, 768 }, /* 16 bpp: 0x117, or 279 */ | ||
74 | { 0, 0, 960, 720 }, /* 16 bpp: 0x18A, or 394 */ | ||
75 | { 0, 0, 800, 600 }, /* 16 bpp: 0x114, or 276 */ | ||
76 | { 0, 0, 768, 576 }, /* 16 bpp: 0x182, or 386 */ | ||
77 | { 0, 0, 720, 576 }, /* PAL */ | ||
78 | { 0, 0, 720, 480 }, /* NTSC */ | ||
79 | { 0, 0, 640, 480 }, /* 16 bpp: 0x111, or 273 */ | ||
80 | { 0, 0, 640, 400 }, /* 8 bpp: 0x100, or 256 */ | ||
81 | { 0, 0, 512, 384 }, | ||
82 | { 0, 0, 320, 240 }, | ||
83 | { 0, 0, 320, 200 } | ||
84 | }; | ||
85 | static const struct { | ||
86 | int xres; | ||
87 | int yres; | ||
88 | int pixclock; | ||
89 | int left; | ||
90 | int right; | ||
91 | int upper; | ||
92 | int lower; | ||
93 | int hslen; | ||
94 | int vslen; | ||
95 | int sync; | ||
96 | int vmode; | ||
97 | } vesa_timings[] = { | ||
98 | #ifdef USE_VESA_TIMINGS /* Only tested on Matrox Millenium I */ | ||
99 | { 640, 400, 39771, 48, 16, 39, 8, 96, 2, 2, 0 }, /* 70 Hz */ | ||
100 | { 640, 480, 39683, 48, 16, 33, 10, 96, 2, 0, 0 }, /* 60 Hz */ | ||
101 | { 768, 576, 26101, 144, 16, 28, 6, 112, 4, 0, 0 }, /* 60 Hz */ | ||
102 | { 800, 600, 24038, 144, 24, 28, 8, 112, 6, 0, 0 }, /* 60 Hz */ | ||
103 | { 960, 720, 17686, 144, 24, 28, 8, 112, 4, 0, 0 }, /* 60 Hz */ | ||
104 | { 1024, 768, 15386, 160, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */ | ||
105 | { 1152, 864, 12286, 192, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */ | ||
106 | { 1280, 1024, 9369, 224, 32, 32, 4, 136, 4, 0, 0 }, /* 60 Hz */ | ||
107 | { 1408, 1056, 8214, 256, 40, 32, 5, 144, 5, 0, 0 }, /* 60 Hz */ | ||
108 | { 1600, 1200,/*?*/0, 272, 48, 32, 5, 152, 5, 0, 0 }, /* 60 Hz */ | ||
109 | #else | ||
110 | /* You can generate these timings from your XF86Config file using | ||
111 | the 'modeline2fb' perl script included with the fbset package. | ||
112 | These timings were generated for Matrox Millenium I, 15" monitor. | ||
113 | */ | ||
114 | { 320, 200, 79440, 16, 16, 20, 4, 48, 1, 0, 2 }, /* 70 Hz */ | ||
115 | { 320, 240, 63492, 16, 16, 16, 4, 48, 2, 0, 2 }, /* 72 Hz */ | ||
116 | { 512, 384, 49603, 48, 16, 16, 1, 64, 3, 0, 0 }, /* 78 Hz */ | ||
117 | { 640, 400, 31746, 96, 32, 41, 1, 64, 3, 2, 0 }, /* 85 Hz */ | ||
118 | { 640, 480, 31746, 120, 16, 16, 1, 64, 3, 0, 0 }, /* 75 Hz */ | ||
119 | { 768, 576, 26101, 144, 16, 28, 6, 112, 4, 0, 0 }, /* 60 Hz */ | ||
120 | { 800, 600, 20000, 64, 56, 23, 37, 120, 6, 3, 0 }, /* 72 Hz */ | ||
121 | { 960, 720, 17686, 144, 24, 28, 8, 112, 4, 0, 0 }, /* 60 Hz */ | ||
122 | { 1024, 768, 13333, 144, 24, 29, 3, 136, 6, 0, 0 }, /* 70 Hz */ | ||
123 | { 1152, 864, 12286, 192, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */ | ||
124 | { 1280, 1024, 9369, 224, 32, 32, 4, 136, 4, 0, 0 }, /* 60 Hz */ | ||
125 | { 1408, 1056, 8214, 256, 40, 32, 5, 144, 5, 0, 0 }, /* 60 Hz */ | ||
126 | { 1600, 1200,/*?*/0, 272, 48, 32, 5, 152, 5, 0, 0 }, /* 60 Hz */ | ||
127 | #endif | ||
128 | }; | ||
129 | enum { | ||
130 | FBCON_ROTATE_NONE = 0, | ||
131 | FBCON_ROTATE_CCW = 90, | ||
132 | FBCON_ROTATE_UD = 180, | ||
133 | FBCON_ROTATE_CW = 270 | ||
134 | }; | ||
135 | |||
136 | #define min(a,b) ((a)<(b)?(a):(b)) | ||
137 | |||
138 | /* Initialization/Query functions */ | ||
139 | static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat); | ||
140 | static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); | ||
141 | static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | ||
142 | #ifdef VGA16_FBCON_SUPPORT | ||
143 | static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | ||
144 | #endif | ||
145 | static int FB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); | ||
146 | static void FB_VideoQuit(_THIS); | ||
147 | |||
148 | /* Hardware surface functions */ | ||
149 | static int FB_InitHWSurfaces(_THIS, SDL_Surface *screen, char *base, int size); | ||
150 | static void FB_FreeHWSurfaces(_THIS); | ||
151 | static int FB_AllocHWSurface(_THIS, SDL_Surface *surface); | ||
152 | static int FB_LockHWSurface(_THIS, SDL_Surface *surface); | ||
153 | static void FB_UnlockHWSurface(_THIS, SDL_Surface *surface); | ||
154 | static void FB_FreeHWSurface(_THIS, SDL_Surface *surface); | ||
155 | static void FB_WaitVBL(_THIS); | ||
156 | static void FB_WaitIdle(_THIS); | ||
157 | static int FB_FlipHWSurface(_THIS, SDL_Surface *surface); | ||
158 | |||
159 | /* Internal palette functions */ | ||
160 | static void FB_SavePalette(_THIS, struct fb_fix_screeninfo *finfo, | ||
161 | struct fb_var_screeninfo *vinfo); | ||
162 | static void FB_RestorePalette(_THIS); | ||
163 | |||
164 | /* Shadow buffer functions */ | ||
165 | static FB_bitBlit FB_blit16; | ||
166 | static FB_bitBlit FB_blit16blocked; | ||
167 | |||
168 | static int SDL_getpagesize(void) | ||
169 | { | ||
170 | #ifdef HAVE_GETPAGESIZE | ||
171 | return getpagesize(); | ||
172 | #elif defined(PAGE_SIZE) | ||
173 | return PAGE_SIZE; | ||
174 | #else | ||
175 | #error Can not determine system page size. | ||
176 | return 4096; /* this is what it USED to be in Linux... */ | ||
177 | #endif | ||
178 | } | ||
179 | |||
180 | |||
181 | /* Small wrapper for mmap() so we can play nicely with no-mmu hosts | ||
182 | * (non-mmu hosts disallow the MAP_SHARED flag) */ | ||
183 | |||
184 | static void *do_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset) | ||
185 | { | ||
186 | void *ret; | ||
187 | ret = mmap(start, length, prot, flags, fd, offset); | ||
188 | if ( ret == (char *)-1 && (flags & MAP_SHARED) ) { | ||
189 | ret = mmap(start, length, prot, | ||
190 | (flags & ~MAP_SHARED) | MAP_PRIVATE, fd, offset); | ||
191 | } | ||
192 | return ret; | ||
193 | } | ||
194 | |||
195 | /* FB driver bootstrap functions */ | ||
196 | |||
197 | static int FB_Available(void) | ||
198 | { | ||
199 | int console = -1; | ||
200 | /* Added check for /fb/0 (devfs) */ | ||
201 | /* but - use environment variable first... if it fails, still check defaults */ | ||
202 | int idx = 0; | ||
203 | const char *SDL_fbdevs[4] = { NULL, "/dev/fb0", "/dev/fb/0", NULL }; | ||
204 | |||
205 | SDL_fbdevs[0] = SDL_getenv("SDL_FBDEV"); | ||
206 | if( !SDL_fbdevs[0] ) | ||
207 | idx++; | ||
208 | for( ; SDL_fbdevs[idx]; idx++ ) | ||
209 | { | ||
210 | console = open(SDL_fbdevs[idx], O_RDWR, 0); | ||
211 | if ( console >= 0 ) { | ||
212 | close(console); | ||
213 | break; | ||
214 | } | ||
215 | } | ||
216 | return(console >= 0); | ||
217 | } | ||
218 | |||
219 | static void FB_DeleteDevice(SDL_VideoDevice *device) | ||
220 | { | ||
221 | SDL_free(device->hidden); | ||
222 | SDL_free(device); | ||
223 | } | ||
224 | |||
225 | static SDL_VideoDevice *FB_CreateDevice(int devindex) | ||
226 | { | ||
227 | SDL_VideoDevice *this; | ||
228 | |||
229 | /* Initialize all variables that we clean on shutdown */ | ||
230 | this = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); | ||
231 | if ( this ) { | ||
232 | SDL_memset(this, 0, (sizeof *this)); | ||
233 | this->hidden = (struct SDL_PrivateVideoData *) | ||
234 | SDL_malloc((sizeof *this->hidden)); | ||
235 | } | ||
236 | if ( (this == NULL) || (this->hidden == NULL) ) { | ||
237 | SDL_OutOfMemory(); | ||
238 | if ( this ) { | ||
239 | SDL_free(this); | ||
240 | } | ||
241 | return(0); | ||
242 | } | ||
243 | SDL_memset(this->hidden, 0, (sizeof *this->hidden)); | ||
244 | wait_vbl = FB_WaitVBL; | ||
245 | wait_idle = FB_WaitIdle; | ||
246 | mouse_fd = -1; | ||
247 | keyboard_fd = -1; | ||
248 | |||
249 | /* Set the function pointers */ | ||
250 | this->VideoInit = FB_VideoInit; | ||
251 | this->ListModes = FB_ListModes; | ||
252 | this->SetVideoMode = FB_SetVideoMode; | ||
253 | this->SetColors = FB_SetColors; | ||
254 | this->UpdateRects = NULL; | ||
255 | this->VideoQuit = FB_VideoQuit; | ||
256 | this->AllocHWSurface = FB_AllocHWSurface; | ||
257 | this->CheckHWBlit = NULL; | ||
258 | this->FillHWRect = NULL; | ||
259 | this->SetHWColorKey = NULL; | ||
260 | this->SetHWAlpha = NULL; | ||
261 | this->LockHWSurface = FB_LockHWSurface; | ||
262 | this->UnlockHWSurface = FB_UnlockHWSurface; | ||
263 | this->FlipHWSurface = FB_FlipHWSurface; | ||
264 | this->FreeHWSurface = FB_FreeHWSurface; | ||
265 | this->SetCaption = NULL; | ||
266 | this->SetIcon = NULL; | ||
267 | this->IconifyWindow = NULL; | ||
268 | this->GrabInput = NULL; | ||
269 | this->GetWMInfo = NULL; | ||
270 | this->InitOSKeymap = FB_InitOSKeymap; | ||
271 | this->PumpEvents = FB_PumpEvents; | ||
272 | |||
273 | this->free = FB_DeleteDevice; | ||
274 | |||
275 | return this; | ||
276 | } | ||
277 | |||
278 | VideoBootStrap FBCON_bootstrap = { | ||
279 | "fbcon", "Linux Framebuffer Console", | ||
280 | FB_Available, FB_CreateDevice | ||
281 | }; | ||
282 | |||
283 | #define FB_MODES_DB "/etc/fb.modes" | ||
284 | |||
285 | static int read_fbmodes_line(FILE*f, char* line, int length) | ||
286 | { | ||
287 | int blank; | ||
288 | char* c; | ||
289 | int i; | ||
290 | |||
291 | blank=0; | ||
292 | /* find a relevant line */ | ||
293 | do | ||
294 | { | ||
295 | if (!fgets(line,length,f)) | ||
296 | return 0; | ||
297 | c=line; | ||
298 | while(((*c=='\t')||(*c==' '))&&(*c!=0)) | ||
299 | c++; | ||
300 | |||
301 | if ((*c=='\n')||(*c=='#')||(*c==0)) | ||
302 | blank=1; | ||
303 | else | ||
304 | blank=0; | ||
305 | } | ||
306 | while(blank); | ||
307 | /* remove whitespace at the begining of the string */ | ||
308 | i=0; | ||
309 | do | ||
310 | { | ||
311 | line[i]=c[i]; | ||
312 | i++; | ||
313 | } | ||
314 | while(c[i]!=0); | ||
315 | return 1; | ||
316 | } | ||
317 | |||
318 | static int read_fbmodes_mode(FILE *f, struct fb_var_screeninfo *vinfo) | ||
319 | { | ||
320 | char line[1024]; | ||
321 | char option[256]; | ||
322 | |||
323 | /* Find a "geometry" */ | ||
324 | do { | ||
325 | if (read_fbmodes_line(f, line, sizeof(line))==0) | ||
326 | return 0; | ||
327 | if (SDL_strncmp(line,"geometry",8)==0) | ||
328 | break; | ||
329 | } | ||
330 | while(1); | ||
331 | |||
332 | SDL_sscanf(line, "geometry %d %d %d %d %d", &vinfo->xres, &vinfo->yres, | ||
333 | &vinfo->xres_virtual, &vinfo->yres_virtual, &vinfo->bits_per_pixel); | ||
334 | if (read_fbmodes_line(f, line, sizeof(line))==0) | ||
335 | return 0; | ||
336 | |||
337 | SDL_sscanf(line, "timings %d %d %d %d %d %d %d", &vinfo->pixclock, | ||
338 | &vinfo->left_margin, &vinfo->right_margin, &vinfo->upper_margin, | ||
339 | &vinfo->lower_margin, &vinfo->hsync_len, &vinfo->vsync_len); | ||
340 | |||
341 | vinfo->sync=0; | ||
342 | vinfo->vmode=FB_VMODE_NONINTERLACED; | ||
343 | |||
344 | /* Parse misc options */ | ||
345 | do { | ||
346 | if (read_fbmodes_line(f, line, sizeof(line))==0) | ||
347 | return 0; | ||
348 | |||
349 | if (SDL_strncmp(line,"hsync",5)==0) { | ||
350 | SDL_sscanf(line,"hsync %s",option); | ||
351 | if (SDL_strncmp(option,"high",4)==0) | ||
352 | vinfo->sync |= FB_SYNC_HOR_HIGH_ACT; | ||
353 | } | ||
354 | else if (SDL_strncmp(line,"vsync",5)==0) { | ||
355 | SDL_sscanf(line,"vsync %s",option); | ||
356 | if (SDL_strncmp(option,"high",4)==0) | ||
357 | vinfo->sync |= FB_SYNC_VERT_HIGH_ACT; | ||
358 | } | ||
359 | else if (SDL_strncmp(line,"csync",5)==0) { | ||
360 | SDL_sscanf(line,"csync %s",option); | ||
361 | if (SDL_strncmp(option,"high",4)==0) | ||
362 | vinfo->sync |= FB_SYNC_COMP_HIGH_ACT; | ||
363 | } | ||
364 | else if (SDL_strncmp(line,"extsync",5)==0) { | ||
365 | SDL_sscanf(line,"extsync %s",option); | ||
366 | if (SDL_strncmp(option,"true",4)==0) | ||
367 | vinfo->sync |= FB_SYNC_EXT; | ||
368 | } | ||
369 | else if (SDL_strncmp(line,"laced",5)==0) { | ||
370 | SDL_sscanf(line,"laced %s",option); | ||
371 | if (SDL_strncmp(option,"true",4)==0) | ||
372 | vinfo->vmode |= FB_VMODE_INTERLACED; | ||
373 | } | ||
374 | else if (SDL_strncmp(line,"double",6)==0) { | ||
375 | SDL_sscanf(line,"double %s",option); | ||
376 | if (SDL_strncmp(option,"true",4)==0) | ||
377 | vinfo->vmode |= FB_VMODE_DOUBLE; | ||
378 | } | ||
379 | } | ||
380 | while(SDL_strncmp(line,"endmode",7)!=0); | ||
381 | |||
382 | return 1; | ||
383 | } | ||
384 | |||
385 | static int FB_CheckMode(_THIS, struct fb_var_screeninfo *vinfo, | ||
386 | int index, unsigned int *w, unsigned int *h) | ||
387 | { | ||
388 | int mode_okay; | ||
389 | |||
390 | mode_okay = 0; | ||
391 | vinfo->bits_per_pixel = (index+1)*8; | ||
392 | vinfo->xres = *w; | ||
393 | vinfo->xres_virtual = *w; | ||
394 | vinfo->yres = *h; | ||
395 | vinfo->yres_virtual = *h; | ||
396 | vinfo->activate = FB_ACTIVATE_TEST; | ||
397 | if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, vinfo) == 0 ) { | ||
398 | #ifdef FBCON_DEBUG | ||
399 | fprintf(stderr, "Checked mode %dx%d at %d bpp, got mode %dx%d at %d bpp\n", *w, *h, (index+1)*8, vinfo->xres, vinfo->yres, vinfo->bits_per_pixel); | ||
400 | #endif | ||
401 | if ( (((vinfo->bits_per_pixel+7)/8)-1) == index ) { | ||
402 | *w = vinfo->xres; | ||
403 | *h = vinfo->yres; | ||
404 | mode_okay = 1; | ||
405 | } | ||
406 | } | ||
407 | return mode_okay; | ||
408 | } | ||
409 | |||
410 | static int FB_AddMode(_THIS, int index, unsigned int w, unsigned int h, int check_timings) | ||
411 | { | ||
412 | SDL_Rect *mode; | ||
413 | int i; | ||
414 | int next_mode; | ||
415 | |||
416 | /* Check to see if we already have this mode */ | ||
417 | if ( SDL_nummodes[index] > 0 ) { | ||
418 | mode = SDL_modelist[index][SDL_nummodes[index]-1]; | ||
419 | if ( (mode->w == w) && (mode->h == h) ) { | ||
420 | #ifdef FBCON_DEBUG | ||
421 | fprintf(stderr, "We already have mode %dx%d at %d bytes per pixel\n", w, h, index+1); | ||
422 | #endif | ||
423 | return(0); | ||
424 | } | ||
425 | } | ||
426 | |||
427 | /* Only allow a mode if we have a valid timing for it */ | ||
428 | if ( check_timings ) { | ||
429 | int found_timing = 0; | ||
430 | for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) { | ||
431 | if ( (w == vesa_timings[i].xres) && | ||
432 | (h == vesa_timings[i].yres) && vesa_timings[i].pixclock ) { | ||
433 | found_timing = 1; | ||
434 | break; | ||
435 | } | ||
436 | } | ||
437 | if ( !found_timing ) { | ||
438 | #ifdef FBCON_DEBUG | ||
439 | fprintf(stderr, "No valid timing line for mode %dx%d\n", w, h); | ||
440 | #endif | ||
441 | return(0); | ||
442 | } | ||
443 | } | ||
444 | |||
445 | /* Set up the new video mode rectangle */ | ||
446 | mode = (SDL_Rect *)SDL_malloc(sizeof *mode); | ||
447 | if ( mode == NULL ) { | ||
448 | SDL_OutOfMemory(); | ||
449 | return(-1); | ||
450 | } | ||
451 | mode->x = 0; | ||
452 | mode->y = 0; | ||
453 | mode->w = w; | ||
454 | mode->h = h; | ||
455 | #ifdef FBCON_DEBUG | ||
456 | fprintf(stderr, "Adding mode %dx%d at %d bytes per pixel\n", w, h, index+1); | ||
457 | #endif | ||
458 | |||
459 | /* Allocate the new list of modes, and fill in the new mode */ | ||
460 | next_mode = SDL_nummodes[index]; | ||
461 | SDL_modelist[index] = (SDL_Rect **) | ||
462 | SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); | ||
463 | if ( SDL_modelist[index] == NULL ) { | ||
464 | SDL_OutOfMemory(); | ||
465 | SDL_nummodes[index] = 0; | ||
466 | SDL_free(mode); | ||
467 | return(-1); | ||
468 | } | ||
469 | SDL_modelist[index][next_mode] = mode; | ||
470 | SDL_modelist[index][next_mode+1] = NULL; | ||
471 | SDL_nummodes[index]++; | ||
472 | |||
473 | return(0); | ||
474 | } | ||
475 | |||
476 | static int cmpmodes(const void *va, const void *vb) | ||
477 | { | ||
478 | const SDL_Rect *a = *(const SDL_Rect**)va; | ||
479 | const SDL_Rect *b = *(const SDL_Rect**)vb; | ||
480 | if ( a->h == b->h ) | ||
481 | return b->w - a->w; | ||
482 | else | ||
483 | return b->h - a->h; | ||
484 | } | ||
485 | |||
486 | static void FB_SortModes(_THIS) | ||
487 | { | ||
488 | int i; | ||
489 | for ( i=0; i<NUM_MODELISTS; ++i ) { | ||
490 | if ( SDL_nummodes[i] > 0 ) { | ||
491 | SDL_qsort(SDL_modelist[i], SDL_nummodes[i], sizeof *SDL_modelist[i], cmpmodes); | ||
492 | } | ||
493 | } | ||
494 | } | ||
495 | |||
496 | static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat) | ||
497 | { | ||
498 | const int pagesize = SDL_getpagesize(); | ||
499 | struct fb_fix_screeninfo finfo; | ||
500 | struct fb_var_screeninfo vinfo; | ||
501 | int i, j; | ||
502 | int current_index; | ||
503 | unsigned int current_w; | ||
504 | unsigned int current_h; | ||
505 | const char *SDL_fbdev; | ||
506 | const char *rotation; | ||
507 | FILE *modesdb; | ||
508 | |||
509 | /* Initialize the library */ | ||
510 | SDL_fbdev = SDL_getenv("SDL_FBDEV"); | ||
511 | if ( SDL_fbdev == NULL ) { | ||
512 | SDL_fbdev = "/dev/fb0"; | ||
513 | } | ||
514 | console_fd = open(SDL_fbdev, O_RDWR, 0); | ||
515 | if ( console_fd < 0 ) { | ||
516 | SDL_SetError("Unable to open %s", SDL_fbdev); | ||
517 | return(-1); | ||
518 | } | ||
519 | |||
520 | #if !SDL_THREADS_DISABLED | ||
521 | /* Create the hardware surface lock mutex */ | ||
522 | hw_lock = SDL_CreateMutex(); | ||
523 | if ( hw_lock == NULL ) { | ||
524 | SDL_SetError("Unable to create lock mutex"); | ||
525 | FB_VideoQuit(this); | ||
526 | return(-1); | ||
527 | } | ||
528 | #endif | ||
529 | |||
530 | /* Get the type of video hardware */ | ||
531 | if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) { | ||
532 | SDL_SetError("Couldn't get console hardware info"); | ||
533 | FB_VideoQuit(this); | ||
534 | return(-1); | ||
535 | } | ||
536 | switch (finfo.type) { | ||
537 | case FB_TYPE_PACKED_PIXELS: | ||
538 | /* Supported, no worries.. */ | ||
539 | break; | ||
540 | #ifdef VGA16_FBCON_SUPPORT | ||
541 | case FB_TYPE_VGA_PLANES: | ||
542 | /* VGA16 is supported, but that's it */ | ||
543 | if ( finfo.type_aux == FB_AUX_VGA_PLANES_VGA4 ) { | ||
544 | if ( ioperm(0x3b4, 0x3df - 0x3b4 + 1, 1) < 0 ) { | ||
545 | SDL_SetError("No I/O port permissions"); | ||
546 | FB_VideoQuit(this); | ||
547 | return(-1); | ||
548 | } | ||
549 | this->SetVideoMode = FB_SetVGA16Mode; | ||
550 | break; | ||
551 | } | ||
552 | /* Fall through to unsupported case */ | ||
553 | #endif /* VGA16_FBCON_SUPPORT */ | ||
554 | default: | ||
555 | SDL_SetError("Unsupported console hardware"); | ||
556 | FB_VideoQuit(this); | ||
557 | return(-1); | ||
558 | } | ||
559 | switch (finfo.visual) { | ||
560 | case FB_VISUAL_TRUECOLOR: | ||
561 | case FB_VISUAL_PSEUDOCOLOR: | ||
562 | case FB_VISUAL_STATIC_PSEUDOCOLOR: | ||
563 | case FB_VISUAL_DIRECTCOLOR: | ||
564 | break; | ||
565 | default: | ||
566 | SDL_SetError("Unsupported console hardware"); | ||
567 | FB_VideoQuit(this); | ||
568 | return(-1); | ||
569 | } | ||
570 | |||
571 | /* Check if the user wants to disable hardware acceleration */ | ||
572 | { const char *fb_accel; | ||
573 | fb_accel = SDL_getenv("SDL_FBACCEL"); | ||
574 | if ( fb_accel ) { | ||
575 | finfo.accel = SDL_atoi(fb_accel); | ||
576 | } | ||
577 | } | ||
578 | |||
579 | /* Memory map the device, compensating for buggy PPC mmap() */ | ||
580 | mapped_offset = (((long)finfo.smem_start) - | ||
581 | (((long)finfo.smem_start)&~(pagesize-1))); | ||
582 | mapped_memlen = finfo.smem_len+mapped_offset; | ||
583 | mapped_mem = do_mmap(NULL, mapped_memlen, | ||
584 | PROT_READ|PROT_WRITE, MAP_SHARED, console_fd, 0); | ||
585 | if ( mapped_mem == (char *)-1 ) { | ||
586 | SDL_SetError("Unable to memory map the video hardware"); | ||
587 | mapped_mem = NULL; | ||
588 | FB_VideoQuit(this); | ||
589 | return(-1); | ||
590 | } | ||
591 | |||
592 | /* Determine the current screen depth */ | ||
593 | if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) { | ||
594 | SDL_SetError("Couldn't get console pixel format"); | ||
595 | FB_VideoQuit(this); | ||
596 | return(-1); | ||
597 | } | ||
598 | vformat->BitsPerPixel = vinfo.bits_per_pixel; | ||
599 | if ( vformat->BitsPerPixel < 8 ) { | ||
600 | /* Assuming VGA16, we handle this via a shadow framebuffer */ | ||
601 | vformat->BitsPerPixel = 8; | ||
602 | } | ||
603 | for ( i=0; i<vinfo.red.length; ++i ) { | ||
604 | vformat->Rmask <<= 1; | ||
605 | vformat->Rmask |= (0x00000001<<vinfo.red.offset); | ||
606 | } | ||
607 | for ( i=0; i<vinfo.green.length; ++i ) { | ||
608 | vformat->Gmask <<= 1; | ||
609 | vformat->Gmask |= (0x00000001<<vinfo.green.offset); | ||
610 | } | ||
611 | for ( i=0; i<vinfo.blue.length; ++i ) { | ||
612 | vformat->Bmask <<= 1; | ||
613 | vformat->Bmask |= (0x00000001<<vinfo.blue.offset); | ||
614 | } | ||
615 | saved_vinfo = vinfo; | ||
616 | |||
617 | /* Save hardware palette, if needed */ | ||
618 | FB_SavePalette(this, &finfo, &vinfo); | ||
619 | |||
620 | /* If the I/O registers are available, memory map them so we | ||
621 | can take advantage of any supported hardware acceleration. | ||
622 | */ | ||
623 | vinfo.accel_flags = 0; /* Temporarily reserve registers */ | ||
624 | ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo); | ||
625 | if ( finfo.accel && finfo.mmio_len ) { | ||
626 | mapped_iolen = finfo.mmio_len; | ||
627 | mapped_io = do_mmap(NULL, mapped_iolen, PROT_READ|PROT_WRITE, | ||
628 | MAP_SHARED, console_fd, mapped_memlen); | ||
629 | if ( mapped_io == (char *)-1 ) { | ||
630 | /* Hmm, failed to memory map I/O registers */ | ||
631 | mapped_io = NULL; | ||
632 | } | ||
633 | } | ||
634 | |||
635 | rotate = FBCON_ROTATE_NONE; | ||
636 | rotation = SDL_getenv("SDL_VIDEO_FBCON_ROTATION"); | ||
637 | if (rotation != NULL) { | ||
638 | if (SDL_strlen(rotation) == 0) { | ||
639 | shadow_fb = 0; | ||
640 | rotate = FBCON_ROTATE_NONE; | ||
641 | #ifdef FBCON_DEBUG | ||
642 | printf("Not rotating, no shadow\n"); | ||
643 | #endif | ||
644 | } else if (!SDL_strcmp(rotation, "NONE")) { | ||
645 | shadow_fb = 1; | ||
646 | rotate = FBCON_ROTATE_NONE; | ||
647 | #ifdef FBCON_DEBUG | ||
648 | printf("Not rotating, but still using shadow\n"); | ||
649 | #endif | ||
650 | } else if (!SDL_strcmp(rotation, "CW")) { | ||
651 | shadow_fb = 1; | ||
652 | rotate = FBCON_ROTATE_CW; | ||
653 | #ifdef FBCON_DEBUG | ||
654 | printf("Rotating screen clockwise\n"); | ||
655 | #endif | ||
656 | } else if (!SDL_strcmp(rotation, "CCW")) { | ||
657 | shadow_fb = 1; | ||
658 | rotate = FBCON_ROTATE_CCW; | ||
659 | #ifdef FBCON_DEBUG | ||
660 | printf("Rotating screen counter clockwise\n"); | ||
661 | #endif | ||
662 | } else if (!SDL_strcmp(rotation, "UD")) { | ||
663 | shadow_fb = 1; | ||
664 | rotate = FBCON_ROTATE_UD; | ||
665 | #ifdef FBCON_DEBUG | ||
666 | printf("Rotating screen upside down\n"); | ||
667 | #endif | ||
668 | } else { | ||
669 | SDL_SetError("\"%s\" is not a valid value for " | ||
670 | "SDL_VIDEO_FBCON_ROTATION", rotation); | ||
671 | return(-1); | ||
672 | } | ||
673 | } | ||
674 | |||
675 | if (rotate == FBCON_ROTATE_CW || rotate == FBCON_ROTATE_CCW) { | ||
676 | current_w = vinfo.yres; | ||
677 | current_h = vinfo.xres; | ||
678 | } else { | ||
679 | current_w = vinfo.xres; | ||
680 | current_h = vinfo.yres; | ||
681 | } | ||
682 | |||
683 | /* Query for the list of available video modes */ | ||
684 | current_index = ((vinfo.bits_per_pixel+7)/8)-1; | ||
685 | modesdb = fopen(FB_MODES_DB, "r"); | ||
686 | for ( i=0; i<NUM_MODELISTS; ++i ) { | ||
687 | SDL_nummodes[i] = 0; | ||
688 | SDL_modelist[i] = NULL; | ||
689 | } | ||
690 | if ( SDL_getenv("SDL_FB_BROKEN_MODES") != NULL ) { | ||
691 | FB_AddMode(this, current_index, current_w, current_h, 0); | ||
692 | } else if(modesdb) { | ||
693 | while ( read_fbmodes_mode(modesdb, &vinfo) ) { | ||
694 | for ( i=0; i<NUM_MODELISTS; ++i ) { | ||
695 | unsigned int w, h; | ||
696 | |||
697 | if (rotate == FBCON_ROTATE_CW || rotate == FBCON_ROTATE_CCW) { | ||
698 | w = vinfo.yres; | ||
699 | h = vinfo.xres; | ||
700 | } else { | ||
701 | w = vinfo.xres; | ||
702 | h = vinfo.yres; | ||
703 | } | ||
704 | /* See if we are querying for the current mode */ | ||
705 | if ( i == current_index ) { | ||
706 | if ( (current_w > w) || (current_h > h) ) { | ||
707 | /* Only check once */ | ||
708 | FB_AddMode(this, i, current_w, current_h, 0); | ||
709 | current_index = -1; | ||
710 | } | ||
711 | } | ||
712 | if ( FB_CheckMode(this, &vinfo, i, &w, &h) ) { | ||
713 | FB_AddMode(this, i, w, h, 0); | ||
714 | } | ||
715 | } | ||
716 | } | ||
717 | fclose(modesdb); | ||
718 | FB_SortModes(this); | ||
719 | } else { | ||
720 | for ( i=0; i<NUM_MODELISTS; ++i ) { | ||
721 | for ( j=0; j<(sizeof(checkres)/sizeof(checkres[0])); ++j ) { | ||
722 | unsigned int w, h; | ||
723 | |||
724 | if (rotate == FBCON_ROTATE_CW || rotate == FBCON_ROTATE_CCW) { | ||
725 | w = checkres[j].h; | ||
726 | h = checkres[j].w; | ||
727 | } else { | ||
728 | w = checkres[j].w; | ||
729 | h = checkres[j].h; | ||
730 | } | ||
731 | /* See if we are querying for the current mode */ | ||
732 | if ( i == current_index ) { | ||
733 | if ( (current_w > w) || (current_h > h) ) { | ||
734 | /* Only check once */ | ||
735 | FB_AddMode(this, i, current_w, current_h, 0); | ||
736 | current_index = -1; | ||
737 | } | ||
738 | } | ||
739 | if ( FB_CheckMode(this, &vinfo, i, &w, &h) ) { | ||
740 | FB_AddMode(this, i, w, h, 1); | ||
741 | } | ||
742 | } | ||
743 | } | ||
744 | } | ||
745 | |||
746 | this->info.current_w = current_w; | ||
747 | this->info.current_h = current_h; | ||
748 | this->info.wm_available = 0; | ||
749 | this->info.hw_available = !shadow_fb; | ||
750 | this->info.video_mem = shadow_fb ? 0 : finfo.smem_len/1024; | ||
751 | /* Fill in our hardware acceleration capabilities */ | ||
752 | if ( mapped_io ) { | ||
753 | switch (finfo.accel) { | ||
754 | case FB_ACCEL_MATROX_MGA2064W: | ||
755 | case FB_ACCEL_MATROX_MGA1064SG: | ||
756 | case FB_ACCEL_MATROX_MGA2164W: | ||
757 | case FB_ACCEL_MATROX_MGA2164W_AGP: | ||
758 | case FB_ACCEL_MATROX_MGAG100: | ||
759 | /*case FB_ACCEL_MATROX_MGAG200: G200 acceleration broken! */ | ||
760 | case FB_ACCEL_MATROX_MGAG400: | ||
761 | #ifdef FBACCEL_DEBUG | ||
762 | printf("Matrox hardware accelerator!\n"); | ||
763 | #endif | ||
764 | FB_MatroxAccel(this, finfo.accel); | ||
765 | break; | ||
766 | case FB_ACCEL_3DFX_BANSHEE: | ||
767 | #ifdef FBACCEL_DEBUG | ||
768 | printf("3DFX hardware accelerator!\n"); | ||
769 | #endif | ||
770 | FB_3DfxAccel(this, finfo.accel); | ||
771 | break; | ||
772 | case FB_ACCEL_NV3: | ||
773 | case FB_ACCEL_NV4: | ||
774 | #ifdef FBACCEL_DEBUG | ||
775 | printf("NVidia hardware accelerator!\n"); | ||
776 | #endif | ||
777 | FB_RivaAccel(this, finfo.accel); | ||
778 | break; | ||
779 | default: | ||
780 | #ifdef FBACCEL_DEBUG | ||
781 | printf("Unknown hardware accelerator.\n"); | ||
782 | #endif | ||
783 | break; | ||
784 | } | ||
785 | } | ||
786 | |||
787 | if (shadow_fb) { | ||
788 | shadow_mem = (char *)SDL_malloc(mapped_memlen); | ||
789 | if (shadow_mem == NULL) { | ||
790 | SDL_SetError("No memory for shadow"); | ||
791 | return (-1); | ||
792 | } | ||
793 | } | ||
794 | |||
795 | /* Enable mouse and keyboard support */ | ||
796 | if ( FB_OpenKeyboard(this) < 0 ) { | ||
797 | FB_VideoQuit(this); | ||
798 | return(-1); | ||
799 | } | ||
800 | if ( FB_OpenMouse(this) < 0 ) { | ||
801 | const char *sdl_nomouse; | ||
802 | |||
803 | sdl_nomouse = SDL_getenv("SDL_NOMOUSE"); | ||
804 | if ( ! sdl_nomouse ) { | ||
805 | SDL_SetError("Unable to open mouse"); | ||
806 | FB_VideoQuit(this); | ||
807 | return(-1); | ||
808 | } | ||
809 | } | ||
810 | |||
811 | /* We're done! */ | ||
812 | return(0); | ||
813 | } | ||
814 | |||
815 | static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) | ||
816 | { | ||
817 | return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]); | ||
818 | } | ||
819 | |||
820 | /* Various screen update functions available */ | ||
821 | static void FB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); | ||
822 | #ifdef VGA16_FBCON_SUPPORT | ||
823 | static void FB_VGA16Update(_THIS, int numrects, SDL_Rect *rects); | ||
824 | #endif | ||
825 | |||
826 | #ifdef FBCON_DEBUG | ||
827 | static void print_vinfo(struct fb_var_screeninfo *vinfo) | ||
828 | { | ||
829 | fprintf(stderr, "Printing vinfo:\n"); | ||
830 | fprintf(stderr, "\txres: %d\n", vinfo->xres); | ||
831 | fprintf(stderr, "\tyres: %d\n", vinfo->yres); | ||
832 | fprintf(stderr, "\txres_virtual: %d\n", vinfo->xres_virtual); | ||
833 | fprintf(stderr, "\tyres_virtual: %d\n", vinfo->yres_virtual); | ||
834 | fprintf(stderr, "\txoffset: %d\n", vinfo->xoffset); | ||
835 | fprintf(stderr, "\tyoffset: %d\n", vinfo->yoffset); | ||
836 | fprintf(stderr, "\tbits_per_pixel: %d\n", vinfo->bits_per_pixel); | ||
837 | fprintf(stderr, "\tgrayscale: %d\n", vinfo->grayscale); | ||
838 | fprintf(stderr, "\tnonstd: %d\n", vinfo->nonstd); | ||
839 | fprintf(stderr, "\tactivate: %d\n", vinfo->activate); | ||
840 | fprintf(stderr, "\theight: %d\n", vinfo->height); | ||
841 | fprintf(stderr, "\twidth: %d\n", vinfo->width); | ||
842 | fprintf(stderr, "\taccel_flags: %d\n", vinfo->accel_flags); | ||
843 | fprintf(stderr, "\tpixclock: %d\n", vinfo->pixclock); | ||
844 | fprintf(stderr, "\tleft_margin: %d\n", vinfo->left_margin); | ||
845 | fprintf(stderr, "\tright_margin: %d\n", vinfo->right_margin); | ||
846 | fprintf(stderr, "\tupper_margin: %d\n", vinfo->upper_margin); | ||
847 | fprintf(stderr, "\tlower_margin: %d\n", vinfo->lower_margin); | ||
848 | fprintf(stderr, "\thsync_len: %d\n", vinfo->hsync_len); | ||
849 | fprintf(stderr, "\tvsync_len: %d\n", vinfo->vsync_len); | ||
850 | fprintf(stderr, "\tsync: %d\n", vinfo->sync); | ||
851 | fprintf(stderr, "\tvmode: %d\n", vinfo->vmode); | ||
852 | fprintf(stderr, "\tred: %d/%d\n", vinfo->red.length, vinfo->red.offset); | ||
853 | fprintf(stderr, "\tgreen: %d/%d\n", vinfo->green.length, vinfo->green.offset); | ||
854 | fprintf(stderr, "\tblue: %d/%d\n", vinfo->blue.length, vinfo->blue.offset); | ||
855 | fprintf(stderr, "\talpha: %d/%d\n", vinfo->transp.length, vinfo->transp.offset); | ||
856 | } | ||
857 | static void print_finfo(struct fb_fix_screeninfo *finfo) | ||
858 | { | ||
859 | fprintf(stderr, "Printing finfo:\n"); | ||
860 | fprintf(stderr, "\tsmem_start = %p\n", (char *)finfo->smem_start); | ||
861 | fprintf(stderr, "\tsmem_len = %d\n", finfo->smem_len); | ||
862 | fprintf(stderr, "\ttype = %d\n", finfo->type); | ||
863 | fprintf(stderr, "\ttype_aux = %d\n", finfo->type_aux); | ||
864 | fprintf(stderr, "\tvisual = %d\n", finfo->visual); | ||
865 | fprintf(stderr, "\txpanstep = %d\n", finfo->xpanstep); | ||
866 | fprintf(stderr, "\typanstep = %d\n", finfo->ypanstep); | ||
867 | fprintf(stderr, "\tywrapstep = %d\n", finfo->ywrapstep); | ||
868 | fprintf(stderr, "\tline_length = %d\n", finfo->line_length); | ||
869 | fprintf(stderr, "\tmmio_start = %p\n", (char *)finfo->mmio_start); | ||
870 | fprintf(stderr, "\tmmio_len = %d\n", finfo->mmio_len); | ||
871 | fprintf(stderr, "\taccel = %d\n", finfo->accel); | ||
872 | } | ||
873 | #endif | ||
874 | |||
875 | static int choose_fbmodes_mode(struct fb_var_screeninfo *vinfo) | ||
876 | { | ||
877 | int matched; | ||
878 | FILE *modesdb; | ||
879 | struct fb_var_screeninfo cinfo; | ||
880 | |||
881 | matched = 0; | ||
882 | modesdb = fopen(FB_MODES_DB, "r"); | ||
883 | if ( modesdb ) { | ||
884 | /* Parse the mode definition file */ | ||
885 | while ( read_fbmodes_mode(modesdb, &cinfo) ) { | ||
886 | if ( (vinfo->xres == cinfo.xres && vinfo->yres == cinfo.yres) && | ||
887 | (!matched || (vinfo->bits_per_pixel == cinfo.bits_per_pixel)) ) { | ||
888 | vinfo->pixclock = cinfo.pixclock; | ||
889 | vinfo->left_margin = cinfo.left_margin; | ||
890 | vinfo->right_margin = cinfo.right_margin; | ||
891 | vinfo->upper_margin = cinfo.upper_margin; | ||
892 | vinfo->lower_margin = cinfo.lower_margin; | ||
893 | vinfo->hsync_len = cinfo.hsync_len; | ||
894 | vinfo->vsync_len = cinfo.vsync_len; | ||
895 | if ( matched ) { | ||
896 | break; | ||
897 | } | ||
898 | matched = 1; | ||
899 | } | ||
900 | } | ||
901 | fclose(modesdb); | ||
902 | } | ||
903 | return(matched); | ||
904 | } | ||
905 | |||
906 | static int choose_vesa_mode(struct fb_var_screeninfo *vinfo) | ||
907 | { | ||
908 | int matched; | ||
909 | int i; | ||
910 | |||
911 | /* Check for VESA timings */ | ||
912 | matched = 0; | ||
913 | for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) { | ||
914 | if ( (vinfo->xres == vesa_timings[i].xres) && | ||
915 | (vinfo->yres == vesa_timings[i].yres) ) { | ||
916 | #ifdef FBCON_DEBUG | ||
917 | fprintf(stderr, "Using VESA timings for %dx%d\n", | ||
918 | vinfo->xres, vinfo->yres); | ||
919 | #endif | ||
920 | if ( vesa_timings[i].pixclock ) { | ||
921 | vinfo->pixclock = vesa_timings[i].pixclock; | ||
922 | } | ||
923 | vinfo->left_margin = vesa_timings[i].left; | ||
924 | vinfo->right_margin = vesa_timings[i].right; | ||
925 | vinfo->upper_margin = vesa_timings[i].upper; | ||
926 | vinfo->lower_margin = vesa_timings[i].lower; | ||
927 | vinfo->hsync_len = vesa_timings[i].hslen; | ||
928 | vinfo->vsync_len = vesa_timings[i].vslen; | ||
929 | vinfo->sync = vesa_timings[i].sync; | ||
930 | vinfo->vmode = vesa_timings[i].vmode; | ||
931 | matched = 1; | ||
932 | break; | ||
933 | } | ||
934 | } | ||
935 | return(matched); | ||
936 | } | ||
937 | |||
938 | #ifdef VGA16_FBCON_SUPPORT | ||
939 | static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current, | ||
940 | int width, int height, int bpp, Uint32 flags) | ||
941 | { | ||
942 | struct fb_fix_screeninfo finfo; | ||
943 | struct fb_var_screeninfo vinfo; | ||
944 | |||
945 | /* Set the terminal into graphics mode */ | ||
946 | if ( FB_EnterGraphicsMode(this) < 0 ) { | ||
947 | return(NULL); | ||
948 | } | ||
949 | |||
950 | /* Restore the original palette */ | ||
951 | FB_RestorePalette(this); | ||
952 | |||
953 | /* Set the video mode and get the final screen format */ | ||
954 | if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) { | ||
955 | SDL_SetError("Couldn't get console screen info"); | ||
956 | return(NULL); | ||
957 | } | ||
958 | cache_vinfo = vinfo; | ||
959 | #ifdef FBCON_DEBUG | ||
960 | fprintf(stderr, "Printing actual vinfo:\n"); | ||
961 | print_vinfo(&vinfo); | ||
962 | #endif | ||
963 | if ( ! SDL_ReallocFormat(current, bpp, 0, 0, 0, 0) ) { | ||
964 | return(NULL); | ||
965 | } | ||
966 | current->format->palette->ncolors = 16; | ||
967 | |||
968 | /* Get the fixed information about the console hardware. | ||
969 | This is necessary since finfo.line_length changes. | ||
970 | */ | ||
971 | if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) { | ||
972 | SDL_SetError("Couldn't get console hardware info"); | ||
973 | return(NULL); | ||
974 | } | ||
975 | #ifdef FBCON_DEBUG | ||
976 | fprintf(stderr, "Printing actual finfo:\n"); | ||
977 | print_finfo(&finfo); | ||
978 | #endif | ||
979 | |||
980 | /* Save hardware palette, if needed */ | ||
981 | FB_SavePalette(this, &finfo, &vinfo); | ||
982 | |||
983 | /* Set up the new mode framebuffer */ | ||
984 | current->flags = SDL_FULLSCREEN; | ||
985 | current->w = vinfo.xres; | ||
986 | current->h = vinfo.yres; | ||
987 | current->pitch = current->w; | ||
988 | current->pixels = SDL_malloc(current->h*current->pitch); | ||
989 | |||
990 | /* Set the update rectangle function */ | ||
991 | this->UpdateRects = FB_VGA16Update; | ||
992 | |||
993 | /* We're done */ | ||
994 | return(current); | ||
995 | } | ||
996 | #endif /* VGA16_FBCON_SUPPORT */ | ||
997 | |||
998 | static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current, | ||
999 | int width, int height, int bpp, Uint32 flags) | ||
1000 | { | ||
1001 | struct fb_fix_screeninfo finfo; | ||
1002 | struct fb_var_screeninfo vinfo; | ||
1003 | int i; | ||
1004 | Uint32 Rmask; | ||
1005 | Uint32 Gmask; | ||
1006 | Uint32 Bmask; | ||
1007 | char *surfaces_mem; | ||
1008 | int surfaces_len; | ||
1009 | |||
1010 | /* Set the terminal into graphics mode */ | ||
1011 | if ( FB_EnterGraphicsMode(this) < 0 ) { | ||
1012 | return(NULL); | ||
1013 | } | ||
1014 | |||
1015 | /* Restore the original palette */ | ||
1016 | FB_RestorePalette(this); | ||
1017 | |||
1018 | /* Set the video mode and get the final screen format */ | ||
1019 | if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) { | ||
1020 | SDL_SetError("Couldn't get console screen info"); | ||
1021 | return(NULL); | ||
1022 | } | ||
1023 | #ifdef FBCON_DEBUG | ||
1024 | fprintf(stderr, "Printing original vinfo:\n"); | ||
1025 | print_vinfo(&vinfo); | ||
1026 | #endif | ||
1027 | /* Do not use double buffering with shadow buffer */ | ||
1028 | if (shadow_fb) { | ||
1029 | flags &= ~SDL_DOUBLEBUF; | ||
1030 | } | ||
1031 | |||
1032 | if ( (vinfo.xres != width) || (vinfo.yres != height) || | ||
1033 | (vinfo.bits_per_pixel != bpp) || (flags & SDL_DOUBLEBUF) ) { | ||
1034 | vinfo.activate = FB_ACTIVATE_NOW; | ||
1035 | vinfo.accel_flags = 0; | ||
1036 | vinfo.bits_per_pixel = bpp; | ||
1037 | vinfo.xres = width; | ||
1038 | vinfo.xres_virtual = width; | ||
1039 | vinfo.yres = height; | ||
1040 | if ( flags & SDL_DOUBLEBUF ) { | ||
1041 | vinfo.yres_virtual = height*2; | ||
1042 | } else { | ||
1043 | vinfo.yres_virtual = height; | ||
1044 | } | ||
1045 | vinfo.xoffset = 0; | ||
1046 | vinfo.yoffset = 0; | ||
1047 | vinfo.red.length = vinfo.red.offset = 0; | ||
1048 | vinfo.green.length = vinfo.green.offset = 0; | ||
1049 | vinfo.blue.length = vinfo.blue.offset = 0; | ||
1050 | vinfo.transp.length = vinfo.transp.offset = 0; | ||
1051 | if ( ! choose_fbmodes_mode(&vinfo) ) { | ||
1052 | choose_vesa_mode(&vinfo); | ||
1053 | } | ||
1054 | #ifdef FBCON_DEBUG | ||
1055 | fprintf(stderr, "Printing wanted vinfo:\n"); | ||
1056 | print_vinfo(&vinfo); | ||
1057 | #endif | ||
1058 | if ( !shadow_fb && | ||
1059 | ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0 ) { | ||
1060 | vinfo.yres_virtual = height; | ||
1061 | if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0 ) { | ||
1062 | SDL_SetError("Couldn't set console screen info"); | ||
1063 | return(NULL); | ||
1064 | } | ||
1065 | } | ||
1066 | } else { | ||
1067 | int maxheight; | ||
1068 | |||
1069 | /* Figure out how much video memory is available */ | ||
1070 | if ( flags & SDL_DOUBLEBUF ) { | ||
1071 | maxheight = height*2; | ||
1072 | } else { | ||
1073 | maxheight = height; | ||
1074 | } | ||
1075 | if ( vinfo.yres_virtual > maxheight ) { | ||
1076 | vinfo.yres_virtual = maxheight; | ||
1077 | } | ||
1078 | } | ||
1079 | cache_vinfo = vinfo; | ||
1080 | #ifdef FBCON_DEBUG | ||
1081 | fprintf(stderr, "Printing actual vinfo:\n"); | ||
1082 | print_vinfo(&vinfo); | ||
1083 | #endif | ||
1084 | Rmask = 0; | ||
1085 | for ( i=0; i<vinfo.red.length; ++i ) { | ||
1086 | Rmask <<= 1; | ||
1087 | Rmask |= (0x00000001<<vinfo.red.offset); | ||
1088 | } | ||
1089 | Gmask = 0; | ||
1090 | for ( i=0; i<vinfo.green.length; ++i ) { | ||
1091 | Gmask <<= 1; | ||
1092 | Gmask |= (0x00000001<<vinfo.green.offset); | ||
1093 | } | ||
1094 | Bmask = 0; | ||
1095 | for ( i=0; i<vinfo.blue.length; ++i ) { | ||
1096 | Bmask <<= 1; | ||
1097 | Bmask |= (0x00000001<<vinfo.blue.offset); | ||
1098 | } | ||
1099 | if ( ! SDL_ReallocFormat(current, vinfo.bits_per_pixel, | ||
1100 | Rmask, Gmask, Bmask, 0) ) { | ||
1101 | return(NULL); | ||
1102 | } | ||
1103 | |||
1104 | /* Get the fixed information about the console hardware. | ||
1105 | This is necessary since finfo.line_length changes. | ||
1106 | */ | ||
1107 | if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) { | ||
1108 | SDL_SetError("Couldn't get console hardware info"); | ||
1109 | return(NULL); | ||
1110 | } | ||
1111 | |||
1112 | /* Save hardware palette, if needed */ | ||
1113 | FB_SavePalette(this, &finfo, &vinfo); | ||
1114 | |||
1115 | if (shadow_fb) { | ||
1116 | if (vinfo.bits_per_pixel == 16) { | ||
1117 | blitFunc = (rotate == FBCON_ROTATE_NONE || | ||
1118 | rotate == FBCON_ROTATE_UD) ? | ||
1119 | FB_blit16 : FB_blit16blocked; | ||
1120 | } else { | ||
1121 | #ifdef FBCON_DEBUG | ||
1122 | fprintf(stderr, "Init vinfo:\n"); | ||
1123 | print_vinfo(&vinfo); | ||
1124 | #endif | ||
1125 | SDL_SetError("Using software buffer, but no blitter " | ||
1126 | "function is available for %d bpp.", | ||
1127 | vinfo.bits_per_pixel); | ||
1128 | return(NULL); | ||
1129 | } | ||
1130 | } | ||
1131 | |||
1132 | /* Set up the new mode framebuffer */ | ||
1133 | current->flags &= SDL_FULLSCREEN; | ||
1134 | if (shadow_fb) { | ||
1135 | current->flags |= SDL_SWSURFACE; | ||
1136 | } else { | ||
1137 | current->flags |= SDL_HWSURFACE; | ||
1138 | } | ||
1139 | current->w = vinfo.xres; | ||
1140 | current->h = vinfo.yres; | ||
1141 | if (shadow_fb) { | ||
1142 | current->pitch = current->w * ((vinfo.bits_per_pixel + 7) / 8); | ||
1143 | current->pixels = shadow_mem; | ||
1144 | physlinebytes = finfo.line_length; | ||
1145 | } else { | ||
1146 | current->pitch = finfo.line_length; | ||
1147 | current->pixels = mapped_mem+mapped_offset; | ||
1148 | } | ||
1149 | |||
1150 | /* Set up the information for hardware surfaces */ | ||
1151 | surfaces_mem = (char *)current->pixels + | ||
1152 | vinfo.yres_virtual*current->pitch; | ||
1153 | surfaces_len = (shadow_fb) ? | ||
1154 | 0 : (mapped_memlen-(surfaces_mem-mapped_mem)); | ||
1155 | |||
1156 | FB_FreeHWSurfaces(this); | ||
1157 | FB_InitHWSurfaces(this, current, surfaces_mem, surfaces_len); | ||
1158 | |||
1159 | /* Let the application know we have a hardware palette */ | ||
1160 | switch (finfo.visual) { | ||
1161 | case FB_VISUAL_PSEUDOCOLOR: | ||
1162 | current->flags |= SDL_HWPALETTE; | ||
1163 | break; | ||
1164 | default: | ||
1165 | break; | ||
1166 | } | ||
1167 | |||
1168 | /* Update for double-buffering, if we can */ | ||
1169 | if ( flags & SDL_DOUBLEBUF ) { | ||
1170 | if ( vinfo.yres_virtual == (height*2) ) { | ||
1171 | current->flags |= SDL_DOUBLEBUF; | ||
1172 | flip_page = 0; | ||
1173 | flip_address[0] = (char *)current->pixels; | ||
1174 | flip_address[1] = (char *)current->pixels+ | ||
1175 | current->h*current->pitch; | ||
1176 | this->screen = current; | ||
1177 | FB_FlipHWSurface(this, current); | ||
1178 | this->screen = NULL; | ||
1179 | } | ||
1180 | } | ||
1181 | |||
1182 | /* Set the update rectangle function */ | ||
1183 | this->UpdateRects = FB_DirectUpdate; | ||
1184 | |||
1185 | /* We're done */ | ||
1186 | return(current); | ||
1187 | } | ||
1188 | |||
1189 | #ifdef FBCON_DEBUG | ||
1190 | void FB_DumpHWSurfaces(_THIS) | ||
1191 | { | ||
1192 | vidmem_bucket *bucket; | ||
1193 | |||
1194 | printf("Memory left: %d (%d total)\n", surfaces_memleft, surfaces_memtotal); | ||
1195 | printf("\n"); | ||
1196 | printf(" Base Size\n"); | ||
1197 | for ( bucket=&surfaces; bucket; bucket=bucket->next ) { | ||
1198 | printf("Bucket: %p, %d (%s)\n", bucket->base, bucket->size, bucket->used ? "used" : "free"); | ||
1199 | if ( bucket->prev ) { | ||
1200 | if ( bucket->base != bucket->prev->base+bucket->prev->size ) { | ||
1201 | printf("Warning, corrupt bucket list! (prev)\n"); | ||
1202 | } | ||
1203 | } else { | ||
1204 | if ( bucket != &surfaces ) { | ||
1205 | printf("Warning, corrupt bucket list! (!prev)\n"); | ||
1206 | } | ||
1207 | } | ||
1208 | if ( bucket->next ) { | ||
1209 | if ( bucket->next->base != bucket->base+bucket->size ) { | ||
1210 | printf("Warning, corrupt bucket list! (next)\n"); | ||
1211 | } | ||
1212 | } | ||
1213 | } | ||
1214 | printf("\n"); | ||
1215 | } | ||
1216 | #endif | ||
1217 | |||
1218 | static int FB_InitHWSurfaces(_THIS, SDL_Surface *screen, char *base, int size) | ||
1219 | { | ||
1220 | vidmem_bucket *bucket; | ||
1221 | |||
1222 | surfaces_memtotal = size; | ||
1223 | surfaces_memleft = size; | ||
1224 | |||
1225 | if ( surfaces_memleft > 0 ) { | ||
1226 | bucket = (vidmem_bucket *)SDL_malloc(sizeof(*bucket)); | ||
1227 | if ( bucket == NULL ) { | ||
1228 | SDL_OutOfMemory(); | ||
1229 | return(-1); | ||
1230 | } | ||
1231 | bucket->prev = &surfaces; | ||
1232 | bucket->used = 0; | ||
1233 | bucket->dirty = 0; | ||
1234 | bucket->base = base; | ||
1235 | bucket->size = size; | ||
1236 | bucket->next = NULL; | ||
1237 | } else { | ||
1238 | bucket = NULL; | ||
1239 | } | ||
1240 | |||
1241 | surfaces.prev = NULL; | ||
1242 | surfaces.used = 1; | ||
1243 | surfaces.dirty = 0; | ||
1244 | surfaces.base = screen->pixels; | ||
1245 | surfaces.size = (unsigned int)((long)base - (long)surfaces.base); | ||
1246 | surfaces.next = bucket; | ||
1247 | screen->hwdata = (struct private_hwdata *)&surfaces; | ||
1248 | return(0); | ||
1249 | } | ||
1250 | static void FB_FreeHWSurfaces(_THIS) | ||
1251 | { | ||
1252 | vidmem_bucket *bucket, *freeable; | ||
1253 | |||
1254 | bucket = surfaces.next; | ||
1255 | while ( bucket ) { | ||
1256 | freeable = bucket; | ||
1257 | bucket = bucket->next; | ||
1258 | SDL_free(freeable); | ||
1259 | } | ||
1260 | surfaces.next = NULL; | ||
1261 | } | ||
1262 | |||
1263 | static int FB_AllocHWSurface(_THIS, SDL_Surface *surface) | ||
1264 | { | ||
1265 | vidmem_bucket *bucket; | ||
1266 | int size; | ||
1267 | int extra; | ||
1268 | |||
1269 | /* Temporarily, we only allow surfaces the same width as display. | ||
1270 | Some blitters require the pitch between two hardware surfaces | ||
1271 | to be the same. Others have interesting alignment restrictions. | ||
1272 | Until someone who knows these details looks at the code... | ||
1273 | */ | ||
1274 | if ( surface->pitch > SDL_VideoSurface->pitch ) { | ||
1275 | SDL_SetError("Surface requested wider than screen"); | ||
1276 | return(-1); | ||
1277 | } | ||
1278 | surface->pitch = SDL_VideoSurface->pitch; | ||
1279 | size = surface->h * surface->pitch; | ||
1280 | #ifdef FBCON_DEBUG | ||
1281 | fprintf(stderr, "Allocating bucket of %d bytes\n", size); | ||
1282 | #endif | ||
1283 | |||
1284 | /* Quick check for available mem */ | ||
1285 | if ( size > surfaces_memleft ) { | ||
1286 | SDL_SetError("Not enough video memory"); | ||
1287 | return(-1); | ||
1288 | } | ||
1289 | |||
1290 | /* Search for an empty bucket big enough */ | ||
1291 | for ( bucket=&surfaces; bucket; bucket=bucket->next ) { | ||
1292 | if ( ! bucket->used && (size <= bucket->size) ) { | ||
1293 | break; | ||
1294 | } | ||
1295 | } | ||
1296 | if ( bucket == NULL ) { | ||
1297 | SDL_SetError("Video memory too fragmented"); | ||
1298 | return(-1); | ||
1299 | } | ||
1300 | |||
1301 | /* Create a new bucket for left-over memory */ | ||
1302 | extra = (bucket->size - size); | ||
1303 | if ( extra ) { | ||
1304 | vidmem_bucket *newbucket; | ||
1305 | |||
1306 | #ifdef FBCON_DEBUG | ||
1307 | fprintf(stderr, "Adding new free bucket of %d bytes\n", extra); | ||
1308 | #endif | ||
1309 | newbucket = (vidmem_bucket *)SDL_malloc(sizeof(*newbucket)); | ||
1310 | if ( newbucket == NULL ) { | ||
1311 | SDL_OutOfMemory(); | ||
1312 | return(-1); | ||
1313 | } | ||
1314 | newbucket->prev = bucket; | ||
1315 | newbucket->used = 0; | ||
1316 | newbucket->base = bucket->base+size; | ||
1317 | newbucket->size = extra; | ||
1318 | newbucket->next = bucket->next; | ||
1319 | if ( bucket->next ) { | ||
1320 | bucket->next->prev = newbucket; | ||
1321 | } | ||
1322 | bucket->next = newbucket; | ||
1323 | } | ||
1324 | |||
1325 | /* Set the current bucket values and return it! */ | ||
1326 | bucket->used = 1; | ||
1327 | bucket->size = size; | ||
1328 | bucket->dirty = 0; | ||
1329 | #ifdef FBCON_DEBUG | ||
1330 | fprintf(stderr, "Allocated %d bytes at %p\n", bucket->size, bucket->base); | ||
1331 | #endif | ||
1332 | surfaces_memleft -= size; | ||
1333 | surface->flags |= SDL_HWSURFACE; | ||
1334 | surface->pixels = bucket->base; | ||
1335 | surface->hwdata = (struct private_hwdata *)bucket; | ||
1336 | return(0); | ||
1337 | } | ||
1338 | static void FB_FreeHWSurface(_THIS, SDL_Surface *surface) | ||
1339 | { | ||
1340 | vidmem_bucket *bucket, *freeable; | ||
1341 | |||
1342 | /* Look for the bucket in the current list */ | ||
1343 | for ( bucket=&surfaces; bucket; bucket=bucket->next ) { | ||
1344 | if ( bucket == (vidmem_bucket *)surface->hwdata ) { | ||
1345 | break; | ||
1346 | } | ||
1347 | } | ||
1348 | if ( bucket && bucket->used ) { | ||
1349 | /* Add the memory back to the total */ | ||
1350 | #ifdef DGA_DEBUG | ||
1351 | printf("Freeing bucket of %d bytes\n", bucket->size); | ||
1352 | #endif | ||
1353 | surfaces_memleft += bucket->size; | ||
1354 | |||
1355 | /* Can we merge the space with surrounding buckets? */ | ||
1356 | bucket->used = 0; | ||
1357 | if ( bucket->next && ! bucket->next->used ) { | ||
1358 | #ifdef DGA_DEBUG | ||
1359 | printf("Merging with next bucket, for %d total bytes\n", bucket->size+bucket->next->size); | ||
1360 | #endif | ||
1361 | freeable = bucket->next; | ||
1362 | bucket->size += bucket->next->size; | ||
1363 | bucket->next = bucket->next->next; | ||
1364 | if ( bucket->next ) { | ||
1365 | bucket->next->prev = bucket; | ||
1366 | } | ||
1367 | SDL_free(freeable); | ||
1368 | } | ||
1369 | if ( bucket->prev && ! bucket->prev->used ) { | ||
1370 | #ifdef DGA_DEBUG | ||
1371 | printf("Merging with previous bucket, for %d total bytes\n", bucket->prev->size+bucket->size); | ||
1372 | #endif | ||
1373 | freeable = bucket; | ||
1374 | bucket->prev->size += bucket->size; | ||
1375 | bucket->prev->next = bucket->next; | ||
1376 | if ( bucket->next ) { | ||
1377 | bucket->next->prev = bucket->prev; | ||
1378 | } | ||
1379 | SDL_free(freeable); | ||
1380 | } | ||
1381 | } | ||
1382 | surface->pixels = NULL; | ||
1383 | surface->hwdata = NULL; | ||
1384 | } | ||
1385 | |||
1386 | static int FB_LockHWSurface(_THIS, SDL_Surface *surface) | ||
1387 | { | ||
1388 | if ( switched_away ) { | ||
1389 | return -2; /* no hardware access */ | ||
1390 | } | ||
1391 | if ( surface == this->screen ) { | ||
1392 | SDL_mutexP(hw_lock); | ||
1393 | if ( FB_IsSurfaceBusy(surface) ) { | ||
1394 | FB_WaitBusySurfaces(this); | ||
1395 | } | ||
1396 | } else { | ||
1397 | if ( FB_IsSurfaceBusy(surface) ) { | ||
1398 | FB_WaitBusySurfaces(this); | ||
1399 | } | ||
1400 | } | ||
1401 | return(0); | ||
1402 | } | ||
1403 | static void FB_UnlockHWSurface(_THIS, SDL_Surface *surface) | ||
1404 | { | ||
1405 | if ( surface == this->screen ) { | ||
1406 | SDL_mutexV(hw_lock); | ||
1407 | } | ||
1408 | } | ||
1409 | |||
1410 | static void FB_WaitVBL(_THIS) | ||
1411 | { | ||
1412 | #ifdef FBIOWAITRETRACE /* Heheh, this didn't make it into the main kernel */ | ||
1413 | ioctl(console_fd, FBIOWAITRETRACE, 0); | ||
1414 | #endif | ||
1415 | return; | ||
1416 | } | ||
1417 | |||
1418 | static void FB_WaitIdle(_THIS) | ||
1419 | { | ||
1420 | return; | ||
1421 | } | ||
1422 | |||
1423 | static int FB_FlipHWSurface(_THIS, SDL_Surface *surface) | ||
1424 | { | ||
1425 | if ( switched_away ) { | ||
1426 | return -2; /* no hardware access */ | ||
1427 | } | ||
1428 | |||
1429 | /* Wait for vertical retrace and then flip display */ | ||
1430 | cache_vinfo.yoffset = flip_page*surface->h; | ||
1431 | if ( FB_IsSurfaceBusy(this->screen) ) { | ||
1432 | FB_WaitBusySurfaces(this); | ||
1433 | } | ||
1434 | wait_vbl(this); | ||
1435 | if ( ioctl(console_fd, FBIOPAN_DISPLAY, &cache_vinfo) < 0 ) { | ||
1436 | SDL_SetError("ioctl(FBIOPAN_DISPLAY) failed"); | ||
1437 | return(-1); | ||
1438 | } | ||
1439 | flip_page = !flip_page; | ||
1440 | |||
1441 | surface->pixels = flip_address[flip_page]; | ||
1442 | return(0); | ||
1443 | } | ||
1444 | |||
1445 | static void FB_blit16(Uint8 *byte_src_pos, int src_right_delta, int src_down_delta, | ||
1446 | Uint8 *byte_dst_pos, int dst_linebytes, int width, int height) | ||
1447 | { | ||
1448 | int w; | ||
1449 | Uint16 *src_pos = (Uint16 *)byte_src_pos; | ||
1450 | Uint16 *dst_pos = (Uint16 *)byte_dst_pos; | ||
1451 | |||
1452 | while (height) { | ||
1453 | Uint16 *src = src_pos; | ||
1454 | Uint16 *dst = dst_pos; | ||
1455 | for (w = width; w != 0; w--) { | ||
1456 | *dst = *src; | ||
1457 | src += src_right_delta; | ||
1458 | dst++; | ||
1459 | } | ||
1460 | dst_pos = (Uint16 *)((Uint8 *)dst_pos + dst_linebytes); | ||
1461 | src_pos += src_down_delta; | ||
1462 | height--; | ||
1463 | } | ||
1464 | } | ||
1465 | |||
1466 | #define BLOCKSIZE_W 32 | ||
1467 | #define BLOCKSIZE_H 32 | ||
1468 | |||
1469 | static void FB_blit16blocked(Uint8 *byte_src_pos, int src_right_delta, int src_down_delta, | ||
1470 | Uint8 *byte_dst_pos, int dst_linebytes, int width, int height) | ||
1471 | { | ||
1472 | int w; | ||
1473 | Uint16 *src_pos = (Uint16 *)byte_src_pos; | ||
1474 | Uint16 *dst_pos = (Uint16 *)byte_dst_pos; | ||
1475 | |||
1476 | while (height > 0) { | ||
1477 | Uint16 *src = src_pos; | ||
1478 | Uint16 *dst = dst_pos; | ||
1479 | for (w = width; w > 0; w -= BLOCKSIZE_W) { | ||
1480 | FB_blit16((Uint8 *)src, | ||
1481 | src_right_delta, | ||
1482 | src_down_delta, | ||
1483 | (Uint8 *)dst, | ||
1484 | dst_linebytes, | ||
1485 | min(w, BLOCKSIZE_W), | ||
1486 | min(height, BLOCKSIZE_H)); | ||
1487 | src += src_right_delta * BLOCKSIZE_W; | ||
1488 | dst += BLOCKSIZE_W; | ||
1489 | } | ||
1490 | dst_pos = (Uint16 *)((Uint8 *)dst_pos + dst_linebytes * BLOCKSIZE_H); | ||
1491 | src_pos += src_down_delta * BLOCKSIZE_H; | ||
1492 | height -= BLOCKSIZE_H; | ||
1493 | } | ||
1494 | } | ||
1495 | |||
1496 | static void FB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) | ||
1497 | { | ||
1498 | int width = cache_vinfo.xres; | ||
1499 | int height = cache_vinfo.yres; | ||
1500 | int bytes_per_pixel = (cache_vinfo.bits_per_pixel + 7) / 8; | ||
1501 | int i; | ||
1502 | |||
1503 | if (!shadow_fb) { | ||
1504 | /* The application is already updating the visible video memory */ | ||
1505 | return; | ||
1506 | } | ||
1507 | |||
1508 | if (cache_vinfo.bits_per_pixel != 16) { | ||
1509 | SDL_SetError("Shadow copy only implemented for 16 bpp"); | ||
1510 | return; | ||
1511 | } | ||
1512 | |||
1513 | for (i = 0; i < numrects; i++) { | ||
1514 | int x1, y1, x2, y2; | ||
1515 | int scr_x1, scr_y1, scr_x2, scr_y2; | ||
1516 | int sha_x1, sha_y1; | ||
1517 | int shadow_right_delta; /* Address change when moving right in dest */ | ||
1518 | int shadow_down_delta; /* Address change when moving down in dest */ | ||
1519 | char *src_start; | ||
1520 | char *dst_start; | ||
1521 | |||
1522 | x1 = rects[i].x; | ||
1523 | y1 = rects[i].y; | ||
1524 | x2 = x1 + rects[i].w; | ||
1525 | y2 = y1 + rects[i].h; | ||
1526 | |||
1527 | if (x1 < 0) { | ||
1528 | x1 = 0; | ||
1529 | } else if (x1 > width) { | ||
1530 | x1 = width; | ||
1531 | } | ||
1532 | if (x2 < 0) { | ||
1533 | x2 = 0; | ||
1534 | } else if (x2 > width) { | ||
1535 | x2 = width; | ||
1536 | } | ||
1537 | if (y1 < 0) { | ||
1538 | y1 = 0; | ||
1539 | } else if (y1 > height) { | ||
1540 | y1 = height; | ||
1541 | } | ||
1542 | if (y2 < 0) { | ||
1543 | y2 = 0; | ||
1544 | } else if (y2 > height) { | ||
1545 | y2 = height; | ||
1546 | } | ||
1547 | if (x2 <= x1 || y2 <= y1) { | ||
1548 | continue; | ||
1549 | } | ||
1550 | |||
1551 | switch (rotate) { | ||
1552 | case FBCON_ROTATE_NONE: | ||
1553 | sha_x1 = scr_x1 = x1; | ||
1554 | sha_y1 = scr_y1 = y1; | ||
1555 | scr_x2 = x2; | ||
1556 | scr_y2 = y2; | ||
1557 | shadow_right_delta = 1; | ||
1558 | shadow_down_delta = width; | ||
1559 | break; | ||
1560 | case FBCON_ROTATE_CCW: | ||
1561 | scr_x1 = y1; | ||
1562 | scr_y1 = width - x2; | ||
1563 | scr_x2 = y2; | ||
1564 | scr_y2 = width - x1; | ||
1565 | sha_x1 = x2 - 1; | ||
1566 | sha_y1 = y1; | ||
1567 | shadow_right_delta = width; | ||
1568 | shadow_down_delta = -1; | ||
1569 | break; | ||
1570 | case FBCON_ROTATE_UD: | ||
1571 | scr_x1 = width - x2; | ||
1572 | scr_y1 = height - y2; | ||
1573 | scr_x2 = width - x1; | ||
1574 | scr_y2 = height - y1; | ||
1575 | sha_x1 = x2 - 1; | ||
1576 | sha_y1 = y2 - 1; | ||
1577 | shadow_right_delta = -1; | ||
1578 | shadow_down_delta = -width; | ||
1579 | break; | ||
1580 | case FBCON_ROTATE_CW: | ||
1581 | scr_x1 = height - y2; | ||
1582 | scr_y1 = x1; | ||
1583 | scr_x2 = height - y1; | ||
1584 | scr_y2 = x2; | ||
1585 | sha_x1 = x1; | ||
1586 | sha_y1 = y2 - 1; | ||
1587 | shadow_right_delta = -width; | ||
1588 | shadow_down_delta = 1; | ||
1589 | break; | ||
1590 | default: | ||
1591 | SDL_SetError("Unknown rotation"); | ||
1592 | return; | ||
1593 | } | ||
1594 | |||
1595 | src_start = shadow_mem + | ||
1596 | (sha_y1 * width + sha_x1) * bytes_per_pixel; | ||
1597 | dst_start = mapped_mem + mapped_offset + scr_y1 * physlinebytes + | ||
1598 | scr_x1 * bytes_per_pixel; | ||
1599 | |||
1600 | blitFunc((Uint8 *) src_start, | ||
1601 | shadow_right_delta, | ||
1602 | shadow_down_delta, | ||
1603 | (Uint8 *) dst_start, | ||
1604 | physlinebytes, | ||
1605 | scr_x2 - scr_x1, | ||
1606 | scr_y2 - scr_y1); | ||
1607 | } | ||
1608 | } | ||
1609 | |||
1610 | #ifdef VGA16_FBCON_SUPPORT | ||
1611 | /* Code adapted with thanks from the XFree86 VGA16 driver! :) */ | ||
1612 | #define writeGr(index, value) \ | ||
1613 | outb(index, 0x3CE); \ | ||
1614 | outb(value, 0x3CF); | ||
1615 | #define writeSeq(index, value) \ | ||
1616 | outb(index, 0x3C4); \ | ||
1617 | outb(value, 0x3C5); | ||
1618 | |||
1619 | static void FB_VGA16Update(_THIS, int numrects, SDL_Rect *rects) | ||
1620 | { | ||
1621 | SDL_Surface *screen; | ||
1622 | int width, height, FBPitch, left, i, j, SRCPitch, phase; | ||
1623 | register Uint32 m; | ||
1624 | Uint8 s1, s2, s3, s4; | ||
1625 | Uint32 *src, *srcPtr; | ||
1626 | Uint8 *dst, *dstPtr; | ||
1627 | |||
1628 | if ( switched_away ) { | ||
1629 | return; /* no hardware access */ | ||
1630 | } | ||
1631 | |||
1632 | screen = this->screen; | ||
1633 | FBPitch = screen->w >> 3; | ||
1634 | SRCPitch = screen->pitch >> 2; | ||
1635 | |||
1636 | writeGr(0x03, 0x00); | ||
1637 | writeGr(0x05, 0x00); | ||
1638 | writeGr(0x01, 0x00); | ||
1639 | writeGr(0x08, 0xFF); | ||
1640 | |||
1641 | while(numrects--) { | ||
1642 | left = rects->x & ~7; | ||
1643 | width = (rects->w + 7) >> 3; | ||
1644 | height = rects->h; | ||
1645 | src = (Uint32*)screen->pixels + (rects->y * SRCPitch) + (left >> 2); | ||
1646 | dst = (Uint8*)mapped_mem + (rects->y * FBPitch) + (left >> 3); | ||
1647 | |||
1648 | if((phase = (long)dst & 3L)) { | ||
1649 | phase = 4 - phase; | ||
1650 | if(phase > width) phase = width; | ||
1651 | width -= phase; | ||
1652 | } | ||
1653 | |||
1654 | while(height--) { | ||
1655 | writeSeq(0x02, 1 << 0); | ||
1656 | dstPtr = dst; | ||
1657 | srcPtr = src; | ||
1658 | i = width; | ||
1659 | j = phase; | ||
1660 | while(j--) { | ||
1661 | m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4); | ||
1662 | *dstPtr++ = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); | ||
1663 | srcPtr += 2; | ||
1664 | } | ||
1665 | while(i >= 4) { | ||
1666 | m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4); | ||
1667 | s1 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); | ||
1668 | m = (srcPtr[3] & 0x01010101) | ((srcPtr[2] & 0x01010101) << 4); | ||
1669 | s2 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); | ||
1670 | m = (srcPtr[5] & 0x01010101) | ((srcPtr[4] & 0x01010101) << 4); | ||
1671 | s3 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); | ||
1672 | m = (srcPtr[7] & 0x01010101) | ((srcPtr[6] & 0x01010101) << 4); | ||
1673 | s4 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); | ||
1674 | *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24); | ||
1675 | srcPtr += 8; | ||
1676 | dstPtr += 4; | ||
1677 | i -= 4; | ||
1678 | } | ||
1679 | while(i--) { | ||
1680 | m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4); | ||
1681 | *dstPtr++ = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); | ||
1682 | srcPtr += 2; | ||
1683 | } | ||
1684 | |||
1685 | writeSeq(0x02, 1 << 1); | ||
1686 | dstPtr = dst; | ||
1687 | srcPtr = src; | ||
1688 | i = width; | ||
1689 | j = phase; | ||
1690 | while(j--) { | ||
1691 | m = (srcPtr[1] & 0x02020202) | ((srcPtr[0] & 0x02020202) << 4); | ||
1692 | *dstPtr++ = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2); | ||
1693 | srcPtr += 2; | ||
1694 | } | ||
1695 | while(i >= 4) { | ||
1696 | m = (srcPtr[1] & 0x02020202) | ((srcPtr[0] & 0x02020202) << 4); | ||
1697 | s1 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2); | ||
1698 | m = (srcPtr[3] & 0x02020202) | ((srcPtr[2] & 0x02020202) << 4); | ||
1699 | s2 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2); | ||
1700 | m = (srcPtr[5] & 0x02020202) | ((srcPtr[4] & 0x02020202) << 4); | ||
1701 | s3 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2); | ||
1702 | m = (srcPtr[7] & 0x02020202) | ((srcPtr[6] & 0x02020202) << 4); | ||
1703 | s4 = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2); | ||
1704 | *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24); | ||
1705 | srcPtr += 8; | ||
1706 | dstPtr += 4; | ||
1707 | i -= 4; | ||
1708 | } | ||
1709 | while(i--) { | ||
1710 | m = (srcPtr[1] & 0x02020202) | ((srcPtr[0] & 0x02020202) << 4); | ||
1711 | *dstPtr++ = (m >> 25) | (m >> 16) | (m >> 7) | (m << 2); | ||
1712 | srcPtr += 2; | ||
1713 | } | ||
1714 | |||
1715 | writeSeq(0x02, 1 << 2); | ||
1716 | dstPtr = dst; | ||
1717 | srcPtr = src; | ||
1718 | i = width; | ||
1719 | j = phase; | ||
1720 | while(j--) { | ||
1721 | m = (srcPtr[1] & 0x04040404) | ((srcPtr[0] & 0x04040404) << 4); | ||
1722 | *dstPtr++ = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1); | ||
1723 | srcPtr += 2; | ||
1724 | } | ||
1725 | while(i >= 4) { | ||
1726 | m = (srcPtr[1] & 0x04040404) | ((srcPtr[0] & 0x04040404) << 4); | ||
1727 | s1 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1); | ||
1728 | m = (srcPtr[3] & 0x04040404) | ((srcPtr[2] & 0x04040404) << 4); | ||
1729 | s2 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1); | ||
1730 | m = (srcPtr[5] & 0x04040404) | ((srcPtr[4] & 0x04040404) << 4); | ||
1731 | s3 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1); | ||
1732 | m = (srcPtr[7] & 0x04040404) | ((srcPtr[6] & 0x04040404) << 4); | ||
1733 | s4 = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1); | ||
1734 | *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24); | ||
1735 | srcPtr += 8; | ||
1736 | dstPtr += 4; | ||
1737 | i -= 4; | ||
1738 | } | ||
1739 | while(i--) { | ||
1740 | m = (srcPtr[1] & 0x04040404) | ((srcPtr[0] & 0x04040404) << 4); | ||
1741 | *dstPtr++ = (m >> 26) | (m >> 17) | (m >> 8) | (m << 1); | ||
1742 | srcPtr += 2; | ||
1743 | } | ||
1744 | |||
1745 | writeSeq(0x02, 1 << 3); | ||
1746 | dstPtr = dst; | ||
1747 | srcPtr = src; | ||
1748 | i = width; | ||
1749 | j = phase; | ||
1750 | while(j--) { | ||
1751 | m = (srcPtr[1] & 0x08080808) | ((srcPtr[0] & 0x08080808) << 4); | ||
1752 | *dstPtr++ = (m >> 27) | (m >> 18) | (m >> 9) | m; | ||
1753 | srcPtr += 2; | ||
1754 | } | ||
1755 | while(i >= 4) { | ||
1756 | m = (srcPtr[1] & 0x08080808) | ((srcPtr[0] & 0x08080808) << 4); | ||
1757 | s1 = (m >> 27) | (m >> 18) | (m >> 9) | m; | ||
1758 | m = (srcPtr[3] & 0x08080808) | ((srcPtr[2] & 0x08080808) << 4); | ||
1759 | s2 = (m >> 27) | (m >> 18) | (m >> 9) | m; | ||
1760 | m = (srcPtr[5] & 0x08080808) | ((srcPtr[4] & 0x08080808) << 4); | ||
1761 | s3 = (m >> 27) | (m >> 18) | (m >> 9) | m; | ||
1762 | m = (srcPtr[7] & 0x08080808) | ((srcPtr[6] & 0x08080808) << 4); | ||
1763 | s4 = (m >> 27) | (m >> 18) | (m >> 9) | m; | ||
1764 | *((Uint32*)dstPtr) = s1 | (s2 << 8) | (s3 << 16) | (s4 << 24); | ||
1765 | srcPtr += 8; | ||
1766 | dstPtr += 4; | ||
1767 | i -= 4; | ||
1768 | } | ||
1769 | while(i--) { | ||
1770 | m = (srcPtr[1] & 0x08080808) | ((srcPtr[0] & 0x08080808) << 4); | ||
1771 | *dstPtr++ = (m >> 27) | (m >> 18) | (m >> 9) | m; | ||
1772 | srcPtr += 2; | ||
1773 | } | ||
1774 | |||
1775 | dst += FBPitch; | ||
1776 | src += SRCPitch; | ||
1777 | } | ||
1778 | rects++; | ||
1779 | } | ||
1780 | } | ||
1781 | #endif /* VGA16_FBCON_SUPPORT */ | ||
1782 | |||
1783 | void FB_SavePaletteTo(_THIS, int palette_len, __u16 *area) | ||
1784 | { | ||
1785 | struct fb_cmap cmap; | ||
1786 | |||
1787 | cmap.start = 0; | ||
1788 | cmap.len = palette_len; | ||
1789 | cmap.red = &area[0*palette_len]; | ||
1790 | cmap.green = &area[1*palette_len]; | ||
1791 | cmap.blue = &area[2*palette_len]; | ||
1792 | cmap.transp = NULL; | ||
1793 | ioctl(console_fd, FBIOGETCMAP, &cmap); | ||
1794 | } | ||
1795 | |||
1796 | void FB_RestorePaletteFrom(_THIS, int palette_len, __u16 *area) | ||
1797 | { | ||
1798 | struct fb_cmap cmap; | ||
1799 | |||
1800 | cmap.start = 0; | ||
1801 | cmap.len = palette_len; | ||
1802 | cmap.red = &area[0*palette_len]; | ||
1803 | cmap.green = &area[1*palette_len]; | ||
1804 | cmap.blue = &area[2*palette_len]; | ||
1805 | cmap.transp = NULL; | ||
1806 | ioctl(console_fd, FBIOPUTCMAP, &cmap); | ||
1807 | } | ||
1808 | |||
1809 | static void FB_SavePalette(_THIS, struct fb_fix_screeninfo *finfo, | ||
1810 | struct fb_var_screeninfo *vinfo) | ||
1811 | { | ||
1812 | int i; | ||
1813 | |||
1814 | /* Save hardware palette, if needed */ | ||
1815 | if ( finfo->visual == FB_VISUAL_PSEUDOCOLOR ) { | ||
1816 | saved_cmaplen = 1<<vinfo->bits_per_pixel; | ||
1817 | saved_cmap=(__u16 *)SDL_malloc(3*saved_cmaplen*sizeof(*saved_cmap)); | ||
1818 | if ( saved_cmap != NULL ) { | ||
1819 | FB_SavePaletteTo(this, saved_cmaplen, saved_cmap); | ||
1820 | } | ||
1821 | } | ||
1822 | |||
1823 | /* Added support for FB_VISUAL_DIRECTCOLOR. | ||
1824 | With this mode pixel information is passed through the palette... | ||
1825 | Neat fading and gamma correction effects can be had by simply | ||
1826 | fooling around with the palette instead of changing the pixel | ||
1827 | values themselves... Very neat! | ||
1828 | |||
1829 | Adam Meyerowitz 1/19/2000 | ||
1830 | ameyerow@optonline.com | ||
1831 | */ | ||
1832 | if ( finfo->visual == FB_VISUAL_DIRECTCOLOR ) { | ||
1833 | __u16 new_entries[3*256]; | ||
1834 | |||
1835 | /* Save the colormap */ | ||
1836 | saved_cmaplen = 256; | ||
1837 | saved_cmap=(__u16 *)SDL_malloc(3*saved_cmaplen*sizeof(*saved_cmap)); | ||
1838 | if ( saved_cmap != NULL ) { | ||
1839 | FB_SavePaletteTo(this, saved_cmaplen, saved_cmap); | ||
1840 | } | ||
1841 | |||
1842 | /* Allocate new identity colormap */ | ||
1843 | for ( i=0; i<256; ++i ) { | ||
1844 | new_entries[(0*256)+i] = | ||
1845 | new_entries[(1*256)+i] = | ||
1846 | new_entries[(2*256)+i] = (i<<8)|i; | ||
1847 | } | ||
1848 | FB_RestorePaletteFrom(this, 256, new_entries); | ||
1849 | } | ||
1850 | } | ||
1851 | |||
1852 | static void FB_RestorePalette(_THIS) | ||
1853 | { | ||
1854 | /* Restore the original palette */ | ||
1855 | if ( saved_cmap ) { | ||
1856 | FB_RestorePaletteFrom(this, saved_cmaplen, saved_cmap); | ||
1857 | SDL_free(saved_cmap); | ||
1858 | saved_cmap = NULL; | ||
1859 | } | ||
1860 | } | ||
1861 | |||
1862 | static int FB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | ||
1863 | { | ||
1864 | int i; | ||
1865 | __u16 r[256]; | ||
1866 | __u16 g[256]; | ||
1867 | __u16 b[256]; | ||
1868 | struct fb_cmap cmap; | ||
1869 | |||
1870 | /* Set up the colormap */ | ||
1871 | for (i = 0; i < ncolors; i++) { | ||
1872 | r[i] = colors[i].r << 8; | ||
1873 | g[i] = colors[i].g << 8; | ||
1874 | b[i] = colors[i].b << 8; | ||
1875 | } | ||
1876 | cmap.start = firstcolor; | ||
1877 | cmap.len = ncolors; | ||
1878 | cmap.red = r; | ||
1879 | cmap.green = g; | ||
1880 | cmap.blue = b; | ||
1881 | cmap.transp = NULL; | ||
1882 | |||
1883 | if( (ioctl(console_fd, FBIOPUTCMAP, &cmap) < 0) || | ||
1884 | !(this->screen->flags & SDL_HWPALETTE) ) { | ||
1885 | colors = this->screen->format->palette->colors; | ||
1886 | ncolors = this->screen->format->palette->ncolors; | ||
1887 | cmap.start = 0; | ||
1888 | cmap.len = ncolors; | ||
1889 | SDL_memset(r, 0, sizeof(r)); | ||
1890 | SDL_memset(g, 0, sizeof(g)); | ||
1891 | SDL_memset(b, 0, sizeof(b)); | ||
1892 | if ( ioctl(console_fd, FBIOGETCMAP, &cmap) == 0 ) { | ||
1893 | for ( i=ncolors-1; i>=0; --i ) { | ||
1894 | colors[i].r = (r[i]>>8); | ||
1895 | colors[i].g = (g[i]>>8); | ||
1896 | colors[i].b = (b[i]>>8); | ||
1897 | } | ||
1898 | } | ||
1899 | return(0); | ||
1900 | } | ||
1901 | return(1); | ||
1902 | } | ||
1903 | |||
1904 | /* Note: If we are terminated, this could be called in the middle of | ||
1905 | another SDL video routine -- notably UpdateRects. | ||
1906 | */ | ||
1907 | static void FB_VideoQuit(_THIS) | ||
1908 | { | ||
1909 | int i, j; | ||
1910 | |||
1911 | if ( this->screen ) { | ||
1912 | /* Clear screen and tell SDL not to free the pixels */ | ||
1913 | |||
1914 | const char *dontClearPixels = SDL_getenv("SDL_FBCON_DONT_CLEAR"); | ||
1915 | |||
1916 | /* If the framebuffer is not to be cleared, make sure that we won't | ||
1917 | * display the previous frame when disabling double buffering. */ | ||
1918 | if ( dontClearPixels && flip_page == 0 ) { | ||
1919 | SDL_memcpy(flip_address[0], flip_address[1], this->screen->pitch * this->screen->h); | ||
1920 | } | ||
1921 | |||
1922 | if ( !dontClearPixels && this->screen->pixels && FB_InGraphicsMode(this) ) { | ||
1923 | #if defined(__powerpc__) || defined(__ia64__) /* SIGBUS when using SDL_memset() ?? */ | ||
1924 | Uint8 *rowp = (Uint8 *)this->screen->pixels; | ||
1925 | int left = this->screen->pitch*this->screen->h; | ||
1926 | while ( left-- ) { *rowp++ = 0; } | ||
1927 | #else | ||
1928 | SDL_memset(this->screen->pixels,0,this->screen->h*this->screen->pitch); | ||
1929 | #endif | ||
1930 | } | ||
1931 | /* This test fails when using the VGA16 shadow memory */ | ||
1932 | if ( ((char *)this->screen->pixels >= mapped_mem) && | ||
1933 | ((char *)this->screen->pixels < (mapped_mem+mapped_memlen)) ) { | ||
1934 | this->screen->pixels = NULL; | ||
1935 | } | ||
1936 | } | ||
1937 | |||
1938 | /* Clear the lock mutex */ | ||
1939 | if ( hw_lock ) { | ||
1940 | SDL_DestroyMutex(hw_lock); | ||
1941 | hw_lock = NULL; | ||
1942 | } | ||
1943 | |||
1944 | /* Clean up defined video modes */ | ||
1945 | for ( i=0; i<NUM_MODELISTS; ++i ) { | ||
1946 | if ( SDL_modelist[i] != NULL ) { | ||
1947 | for ( j=0; SDL_modelist[i][j]; ++j ) { | ||
1948 | SDL_free(SDL_modelist[i][j]); | ||
1949 | } | ||
1950 | SDL_free(SDL_modelist[i]); | ||
1951 | SDL_modelist[i] = NULL; | ||
1952 | } | ||
1953 | } | ||
1954 | |||
1955 | /* Clean up the memory bucket list */ | ||
1956 | FB_FreeHWSurfaces(this); | ||
1957 | |||
1958 | /* Close console and input file descriptors */ | ||
1959 | if ( console_fd > 0 ) { | ||
1960 | /* Unmap the video framebuffer and I/O registers */ | ||
1961 | if ( mapped_mem ) { | ||
1962 | munmap(mapped_mem, mapped_memlen); | ||
1963 | mapped_mem = NULL; | ||
1964 | } | ||
1965 | if ( mapped_io ) { | ||
1966 | munmap(mapped_io, mapped_iolen); | ||
1967 | mapped_io = NULL; | ||
1968 | } | ||
1969 | |||
1970 | /* Restore the original video mode and palette */ | ||
1971 | if ( FB_InGraphicsMode(this) ) { | ||
1972 | FB_RestorePalette(this); | ||
1973 | ioctl(console_fd, FBIOPUT_VSCREENINFO, &saved_vinfo); | ||
1974 | } | ||
1975 | |||
1976 | /* We're all done with the framebuffer */ | ||
1977 | close(console_fd); | ||
1978 | console_fd = -1; | ||
1979 | } | ||
1980 | FB_CloseMouse(this); | ||
1981 | FB_CloseKeyboard(this); | ||
1982 | } | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/SDL_fbvideo.h b/apps/plugins/sdl/src/video/fbcon/SDL_fbvideo.h deleted file mode 100644 index 1443d2b251..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/SDL_fbvideo.h +++ /dev/null | |||
@@ -1,200 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #ifndef _SDL_fbvideo_h | ||
25 | #define _SDL_fbvideo_h | ||
26 | |||
27 | #include <sys/types.h> | ||
28 | #include <termios.h> | ||
29 | #include <linux/fb.h> | ||
30 | |||
31 | #include "SDL_mouse.h" | ||
32 | #include "SDL_mutex.h" | ||
33 | #include "../SDL_sysvideo.h" | ||
34 | #if SDL_INPUT_TSLIB | ||
35 | #include "tslib.h" | ||
36 | #endif | ||
37 | |||
38 | /* Hidden "this" pointer for the video functions */ | ||
39 | #define _THIS SDL_VideoDevice *this | ||
40 | |||
41 | typedef void FB_bitBlit( | ||
42 | Uint8 *src_pos, | ||
43 | int src_right_delta, /* pixels, not bytes */ | ||
44 | int src_down_delta, /* pixels, not bytes */ | ||
45 | Uint8 *dst_pos, | ||
46 | int dst_linebytes, | ||
47 | int width, | ||
48 | int height); | ||
49 | |||
50 | /* This is the structure we use to keep track of video memory */ | ||
51 | typedef struct vidmem_bucket { | ||
52 | struct vidmem_bucket *prev; | ||
53 | int used; | ||
54 | int dirty; | ||
55 | char *base; | ||
56 | unsigned int size; | ||
57 | struct vidmem_bucket *next; | ||
58 | } vidmem_bucket; | ||
59 | |||
60 | /* Private display data */ | ||
61 | struct SDL_PrivateVideoData { | ||
62 | int console_fd; | ||
63 | struct fb_var_screeninfo cache_vinfo; | ||
64 | struct fb_var_screeninfo saved_vinfo; | ||
65 | int saved_cmaplen; | ||
66 | __u16 *saved_cmap; | ||
67 | |||
68 | int current_vt; | ||
69 | int saved_vt; | ||
70 | int keyboard_fd; | ||
71 | int saved_kbd_mode; | ||
72 | struct termios saved_kbd_termios; | ||
73 | |||
74 | int mouse_fd; | ||
75 | #if SDL_INPUT_TSLIB | ||
76 | struct tsdev *ts_dev; | ||
77 | #endif | ||
78 | |||
79 | char *mapped_mem; | ||
80 | char *shadow_mem; | ||
81 | int mapped_memlen; | ||
82 | int mapped_offset; | ||
83 | char *mapped_io; | ||
84 | long mapped_iolen; | ||
85 | int flip_page; | ||
86 | char *flip_address[2]; | ||
87 | int rotate; | ||
88 | int shadow_fb; /* Tells whether a shadow is being used. */ | ||
89 | FB_bitBlit *blitFunc; | ||
90 | int physlinebytes; /* Length of a line in bytes in physical fb */ | ||
91 | |||
92 | #define NUM_MODELISTS 4 /* 8, 16, 24, and 32 bits-per-pixel */ | ||
93 | int SDL_nummodes[NUM_MODELISTS]; | ||
94 | SDL_Rect **SDL_modelist[NUM_MODELISTS]; | ||
95 | |||
96 | vidmem_bucket surfaces; | ||
97 | int surfaces_memtotal; | ||
98 | int surfaces_memleft; | ||
99 | |||
100 | SDL_mutex *hw_lock; | ||
101 | int switched_away; | ||
102 | struct fb_var_screeninfo screen_vinfo; | ||
103 | Uint32 screen_arealen; | ||
104 | Uint8 *screen_contents; | ||
105 | __u16 screen_palette[3*256]; | ||
106 | |||
107 | void (*wait_vbl)(_THIS); | ||
108 | void (*wait_idle)(_THIS); | ||
109 | }; | ||
110 | /* Old variable names */ | ||
111 | #define console_fd (this->hidden->console_fd) | ||
112 | #define current_vt (this->hidden->current_vt) | ||
113 | #define saved_vt (this->hidden->saved_vt) | ||
114 | #define keyboard_fd (this->hidden->keyboard_fd) | ||
115 | #define saved_kbd_mode (this->hidden->saved_kbd_mode) | ||
116 | #define saved_kbd_termios (this->hidden->saved_kbd_termios) | ||
117 | #define mouse_fd (this->hidden->mouse_fd) | ||
118 | #if SDL_INPUT_TSLIB | ||
119 | #define ts_dev (this->hidden->ts_dev) | ||
120 | #endif | ||
121 | #define cache_vinfo (this->hidden->cache_vinfo) | ||
122 | #define saved_vinfo (this->hidden->saved_vinfo) | ||
123 | #define saved_cmaplen (this->hidden->saved_cmaplen) | ||
124 | #define saved_cmap (this->hidden->saved_cmap) | ||
125 | #define mapped_mem (this->hidden->mapped_mem) | ||
126 | #define shadow_mem (this->hidden->shadow_mem) | ||
127 | #define mapped_memlen (this->hidden->mapped_memlen) | ||
128 | #define mapped_offset (this->hidden->mapped_offset) | ||
129 | #define mapped_io (this->hidden->mapped_io) | ||
130 | #define mapped_iolen (this->hidden->mapped_iolen) | ||
131 | #define flip_page (this->hidden->flip_page) | ||
132 | #define flip_address (this->hidden->flip_address) | ||
133 | #define rotate (this->hidden->rotate) | ||
134 | #define shadow_fb (this->hidden->shadow_fb) | ||
135 | #define blitFunc (this->hidden->blitFunc) | ||
136 | #define physlinebytes (this->hidden->physlinebytes) | ||
137 | #define SDL_nummodes (this->hidden->SDL_nummodes) | ||
138 | #define SDL_modelist (this->hidden->SDL_modelist) | ||
139 | #define surfaces (this->hidden->surfaces) | ||
140 | #define surfaces_memtotal (this->hidden->surfaces_memtotal) | ||
141 | #define surfaces_memleft (this->hidden->surfaces_memleft) | ||
142 | #define hw_lock (this->hidden->hw_lock) | ||
143 | #define switched_away (this->hidden->switched_away) | ||
144 | #define screen_vinfo (this->hidden->screen_vinfo) | ||
145 | #define screen_arealen (this->hidden->screen_arealen) | ||
146 | #define screen_contents (this->hidden->screen_contents) | ||
147 | #define screen_palette (this->hidden->screen_palette) | ||
148 | #define wait_vbl (this->hidden->wait_vbl) | ||
149 | #define wait_idle (this->hidden->wait_idle) | ||
150 | |||
151 | /* Accelerator types that are supported by the driver, but are not | ||
152 | necessarily in the kernel headers on the system we compile on. | ||
153 | */ | ||
154 | #ifndef FB_ACCEL_MATROX_MGAG400 | ||
155 | #define FB_ACCEL_MATROX_MGAG400 26 /* Matrox G400 */ | ||
156 | #endif | ||
157 | #ifndef FB_ACCEL_3DFX_BANSHEE | ||
158 | #define FB_ACCEL_3DFX_BANSHEE 31 /* 3Dfx Banshee */ | ||
159 | #endif | ||
160 | |||
161 | /* These functions are defined in SDL_fbvideo.c */ | ||
162 | extern void FB_SavePaletteTo(_THIS, int palette_len, __u16 *area); | ||
163 | extern void FB_RestorePaletteFrom(_THIS, int palette_len, __u16 *area); | ||
164 | |||
165 | /* These are utility functions for working with video surfaces */ | ||
166 | |||
167 | static __inline__ void FB_AddBusySurface(SDL_Surface *surface) | ||
168 | { | ||
169 | ((vidmem_bucket *)surface->hwdata)->dirty = 1; | ||
170 | } | ||
171 | |||
172 | static __inline__ int FB_IsSurfaceBusy(SDL_Surface *surface) | ||
173 | { | ||
174 | return ((vidmem_bucket *)surface->hwdata)->dirty; | ||
175 | } | ||
176 | |||
177 | static __inline__ void FB_WaitBusySurfaces(_THIS) | ||
178 | { | ||
179 | vidmem_bucket *bucket; | ||
180 | |||
181 | /* Wait for graphic operations to complete */ | ||
182 | wait_idle(this); | ||
183 | |||
184 | /* Clear all surface dirty bits */ | ||
185 | for ( bucket=&surfaces; bucket; bucket=bucket->next ) { | ||
186 | bucket->dirty = 0; | ||
187 | } | ||
188 | } | ||
189 | |||
190 | static __inline__ void FB_dst_to_xy(_THIS, SDL_Surface *dst, int *x, int *y) | ||
191 | { | ||
192 | *x = (long)((char *)dst->pixels - mapped_mem)%this->screen->pitch; | ||
193 | *y = (long)((char *)dst->pixels - mapped_mem)/this->screen->pitch; | ||
194 | if ( dst == this->screen ) { | ||
195 | *x += this->offset_x; | ||
196 | *y += this->offset_y; | ||
197 | } | ||
198 | } | ||
199 | |||
200 | #endif /* _SDL_fbvideo_h */ | ||
diff --git a/apps/plugins/sdl/src/video/fbcon/matrox_mmio.h b/apps/plugins/sdl/src/video/fbcon/matrox_mmio.h deleted file mode 100644 index a1cf203ea5..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/matrox_mmio.h +++ /dev/null | |||
@@ -1,51 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* MGA register definitions */ | ||
25 | |||
26 | #include "matrox_regs.h" | ||
27 | |||
28 | /* MGA control macros */ | ||
29 | |||
30 | #define mga_in8(reg) *(volatile Uint8 *)(mapped_io + (reg)) | ||
31 | #define mga_in32(reg) *(volatile Uint32 *)(mapped_io + (reg)) | ||
32 | |||
33 | #define mga_out8(reg,v) *(volatile Uint8 *)(mapped_io + (reg)) = v; | ||
34 | #define mga_out32(reg,v) *(volatile Uint32 *)(mapped_io + (reg)) = v; | ||
35 | |||
36 | |||
37 | /* Wait for fifo space */ | ||
38 | #define mga_wait(space) \ | ||
39 | { \ | ||
40 | while ( mga_in8(MGAREG_FIFOSTATUS) < space ) \ | ||
41 | ; \ | ||
42 | } | ||
43 | |||
44 | |||
45 | /* Wait for idle accelerator */ | ||
46 | #define mga_waitidle() \ | ||
47 | { \ | ||
48 | while ( mga_in32(MGAREG_STATUS) & 0x10000 ) \ | ||
49 | ; \ | ||
50 | } | ||
51 | |||
diff --git a/apps/plugins/sdl/src/video/fbcon/matrox_regs.h b/apps/plugins/sdl/src/video/fbcon/matrox_regs.h deleted file mode 100644 index d570b0c9b0..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/matrox_regs.h +++ /dev/null | |||
@@ -1,376 +0,0 @@ | |||
1 | |||
2 | /* | ||
3 | * MGA Millennium (MGA2064W) functions | ||
4 | * MGA Mystique (MGA1064SG) functions | ||
5 | * | ||
6 | * Copyright 1996 The XFree86 Project, Inc. | ||
7 | * | ||
8 | * Authors | ||
9 | * Dirk Hohndel | ||
10 | * hohndel@XFree86.Org | ||
11 | * David Dawes | ||
12 | * dawes@XFree86.Org | ||
13 | * Contributors: | ||
14 | * Guy DESBIEF, Aix-en-provence, France | ||
15 | * g.desbief@aix.pacwan.net | ||
16 | * MGA1064SG Mystique register file | ||
17 | */ | ||
18 | |||
19 | |||
20 | #ifndef _MGA_REG_H_ | ||
21 | #define _MGA_REG_H_ | ||
22 | |||
23 | #define MGAREG_DWGCTL 0x1c00 | ||
24 | #define MGAREG_MACCESS 0x1c04 | ||
25 | /* the following is a mystique only register */ | ||
26 | #define MGAREG_MCTLWTST 0x1c08 | ||
27 | #define MGAREG_ZORG 0x1c0c | ||
28 | |||
29 | #define MGAREG_PAT0 0x1c10 | ||
30 | #define MGAREG_PAT1 0x1c14 | ||
31 | #define MGAREG_PLNWT 0x1c1c | ||
32 | |||
33 | #define MGAREG_BCOL 0x1c20 | ||
34 | #define MGAREG_FCOL 0x1c24 | ||
35 | |||
36 | #define MGAREG_SRC0 0x1c30 | ||
37 | #define MGAREG_SRC1 0x1c34 | ||
38 | #define MGAREG_SRC2 0x1c38 | ||
39 | #define MGAREG_SRC3 0x1c3c | ||
40 | |||
41 | #define MGAREG_XYSTRT 0x1c40 | ||
42 | #define MGAREG_XYEND 0x1c44 | ||
43 | |||
44 | #define MGAREG_SHIFT 0x1c50 | ||
45 | /* the following is a mystique only register */ | ||
46 | #define MGAREG_DMAPAD 0x1c54 | ||
47 | #define MGAREG_SGN 0x1c58 | ||
48 | #define MGAREG_LEN 0x1c5c | ||
49 | |||
50 | #define MGAREG_AR0 0x1c60 | ||
51 | #define MGAREG_AR1 0x1c64 | ||
52 | #define MGAREG_AR2 0x1c68 | ||
53 | #define MGAREG_AR3 0x1c6c | ||
54 | #define MGAREG_AR4 0x1c70 | ||
55 | #define MGAREG_AR5 0x1c74 | ||
56 | #define MGAREG_AR6 0x1c78 | ||
57 | |||
58 | #define MGAREG_CXBNDRY 0x1c80 | ||
59 | #define MGAREG_FXBNDRY 0x1c84 | ||
60 | #define MGAREG_YDSTLEN 0x1c88 | ||
61 | #define MGAREG_PITCH 0x1c8c | ||
62 | |||
63 | #define MGAREG_YDST 0x1c90 | ||
64 | #define MGAREG_YDSTORG 0x1c94 | ||
65 | #define MGAREG_YTOP 0x1c98 | ||
66 | #define MGAREG_YBOT 0x1c9c | ||
67 | |||
68 | #define MGAREG_CXLEFT 0x1ca0 | ||
69 | #define MGAREG_CXRIGHT 0x1ca4 | ||
70 | #define MGAREG_FXLEFT 0x1ca8 | ||
71 | #define MGAREG_FXRIGHT 0x1cac | ||
72 | |||
73 | #define MGAREG_XDST 0x1cb0 | ||
74 | |||
75 | #define MGAREG_DR0 0x1cc0 | ||
76 | #define MGAREG_DR1 0x1cc4 | ||
77 | #define MGAREG_DR2 0x1cc8 | ||
78 | #define MGAREG_DR3 0x1ccc | ||
79 | |||
80 | #define MGAREG_DR4 0x1cd0 | ||
81 | #define MGAREG_DR5 0x1cd4 | ||
82 | #define MGAREG_DR6 0x1cd8 | ||
83 | #define MGAREG_DR7 0x1cdc | ||
84 | |||
85 | #define MGAREG_DR8 0x1ce0 | ||
86 | #define MGAREG_DR9 0x1ce4 | ||
87 | #define MGAREG_DR10 0x1ce8 | ||
88 | #define MGAREG_DR11 0x1cec | ||
89 | |||
90 | #define MGAREG_DR12 0x1cf0 | ||
91 | #define MGAREG_DR13 0x1cf4 | ||
92 | #define MGAREG_DR14 0x1cf8 | ||
93 | #define MGAREG_DR15 0x1cfc | ||
94 | |||
95 | #define MGAREG_SRCORG 0x2cb4 | ||
96 | #define MGAREG_DSTORG 0x2cb8 | ||
97 | |||
98 | /* add or or this to one of the previous "power registers" to start | ||
99 | the drawing engine */ | ||
100 | |||
101 | #define MGAREG_EXEC 0x0100 | ||
102 | |||
103 | #define MGAREG_FIFOSTATUS 0x1e10 | ||
104 | #define MGAREG_STATUS 0x1e14 | ||
105 | #define MGAREG_ICLEAR 0x1e18 | ||
106 | #define MGAREG_IEN 0x1e1c | ||
107 | |||
108 | #define MGAREG_VCOUNT 0x1e20 | ||
109 | |||
110 | #define MGAREG_Reset 0x1e40 | ||
111 | |||
112 | #define MGAREG_OPMODE 0x1e54 | ||
113 | |||
114 | /* OPMODE register additives */ | ||
115 | |||
116 | #define MGAOPM_DMA_GENERAL (0x00 << 2) | ||
117 | #define MGAOPM_DMA_BLIT (0x01 << 2) | ||
118 | #define MGAOPM_DMA_VECTOR (0x10 << 2) | ||
119 | |||
120 | /* DWGCTL register additives */ | ||
121 | |||
122 | /* Lines */ | ||
123 | |||
124 | #define MGADWG_LINE_OPEN 0x00 | ||
125 | #define MGADWG_AUTOLINE_OPEN 0x01 | ||
126 | #define MGADWG_LINE_CLOSE 0x02 | ||
127 | #define MGADWG_AUTOLINE_CLOSE 0x03 | ||
128 | |||
129 | /* Trapezoids */ | ||
130 | #define MGADWG_TRAP 0x04 | ||
131 | #define MGADWG_TEXTURE_TRAP 0x05 | ||
132 | |||
133 | /* BitBlts */ | ||
134 | |||
135 | #define MGADWG_BITBLT 0x08 | ||
136 | #define MGADWG_FBITBLT 0x0c | ||
137 | #define MGADWG_ILOAD 0x09 | ||
138 | #define MGADWG_ILOAD_SCALE 0x0d | ||
139 | #define MGADWG_ILOAD_FILTER 0x0f | ||
140 | #define MGADWG_IDUMP 0x0a | ||
141 | |||
142 | /* atype access to WRAM */ | ||
143 | |||
144 | #define MGADWG_RPL ( 0x00 << 4 ) | ||
145 | #define MGADWG_RSTR ( 0x01 << 4 ) | ||
146 | #define MGADWG_ZI ( 0x03 << 4 ) | ||
147 | #define MGADWG_BLK ( 0x04 << 4 ) | ||
148 | #define MGADWG_I ( 0x07 << 4 ) | ||
149 | |||
150 | /* specifies whether bit blits are linear or xy */ | ||
151 | #define MGADWG_LINEAR ( 0x01 << 7 ) | ||
152 | |||
153 | /* z drawing mode. use MGADWG_NOZCMP for always */ | ||
154 | |||
155 | #define MGADWG_NOZCMP ( 0x00 << 8 ) | ||
156 | #define MGADWG_ZE ( 0x02 << 8 ) | ||
157 | #define MGADWG_ZNE ( 0x03 << 8 ) | ||
158 | #define MGADWG_ZLT ( 0x04 << 8 ) | ||
159 | #define MGADWG_ZLTE ( 0x05 << 8 ) | ||
160 | #define MGADWG_GT ( 0x06 << 8 ) | ||
161 | #define MGADWG_GTE ( 0x07 << 8 ) | ||
162 | |||
163 | /* use this to force colour expansion circuitry to do its stuff */ | ||
164 | |||
165 | #define MGADWG_SOLID ( 0x01 << 11 ) | ||
166 | |||
167 | /* ar register at zero */ | ||
168 | |||
169 | #define MGADWG_ARZERO ( 0x01 << 12 ) | ||
170 | |||
171 | #define MGADWG_SGNZERO ( 0x01 << 13 ) | ||
172 | |||
173 | #define MGADWG_SHIFTZERO ( 0x01 << 14 ) | ||
174 | |||
175 | /* See table on 4-43 for bop ALU operations */ | ||
176 | |||
177 | /* See table on 4-44 for translucidity masks */ | ||
178 | |||
179 | #define MGADWG_BMONOLEF ( 0x00 << 25 ) | ||
180 | #define MGADWG_BMONOWF ( 0x04 << 25 ) | ||
181 | #define MGADWG_BPLAN ( 0x01 << 25 ) | ||
182 | |||
183 | /* note that if bfcol is specified and you're doing a bitblt, it causes | ||
184 | a fbitblt to be performed, so check that you obey the fbitblt rules */ | ||
185 | |||
186 | #define MGADWG_BFCOL ( 0x02 << 25 ) | ||
187 | #define MGADWG_BUYUV ( 0x0e << 25 ) | ||
188 | #define MGADWG_BU32BGR ( 0x03 << 25 ) | ||
189 | #define MGADWG_BU32RGB ( 0x07 << 25 ) | ||
190 | #define MGADWG_BU24BGR ( 0x0b << 25 ) | ||
191 | #define MGADWG_BU24RGB ( 0x0f << 25 ) | ||
192 | |||
193 | #define MGADWG_REPLACE 0x000C0000 /* From Linux kernel sources */ | ||
194 | #define MGADWG_PATTERN ( 0x01 << 29 ) | ||
195 | #define MGADWG_TRANSC ( 0x01 << 30 ) | ||
196 | #define MGADWG_NOCLIP ( 0x01 << 31 ) | ||
197 | #define MGAREG_MISC_WRITE 0x3c2 | ||
198 | #define MGAREG_MISC_READ 0x3cc | ||
199 | #define MGAREG_MISC_IOADSEL (0x1 << 0) | ||
200 | #define MGAREG_MISC_RAMMAPEN (0x1 << 1) | ||
201 | #define MGAREG_MISC_CLK_SEL_VGA25 (0x0 << 2) | ||
202 | #define MGAREG_MISC_CLK_SEL_VGA28 (0x1 << 2) | ||
203 | #define MGAREG_MISC_CLK_SEL_MGA_PIX (0x2 << 2) | ||
204 | #define MGAREG_MISC_CLK_SEL_MGA_MSK (0x3 << 2) | ||
205 | #define MGAREG_MISC_VIDEO_DIS (0x1 << 4) | ||
206 | #define MGAREG_MISC_HIGH_PG_SEL (0x1 << 5) | ||
207 | |||
208 | /* MMIO VGA registers */ | ||
209 | #define MGAREG_CRTC_INDEX 0x1fd4 | ||
210 | #define MGAREG_CRTC_DATA 0x1fd5 | ||
211 | #define MGAREG_CRTCEXT_INDEX 0x1fde | ||
212 | #define MGAREG_CRTCEXT_DATA 0x1fdf | ||
213 | |||
214 | |||
215 | /* MGA bits for registers PCI_OPTION_REG */ | ||
216 | #define MGA1064_OPT_SYS_CLK_PCI ( 0x00 << 0 ) | ||
217 | #define MGA1064_OPT_SYS_CLK_PLL ( 0x01 << 0 ) | ||
218 | #define MGA1064_OPT_SYS_CLK_EXT ( 0x02 << 0 ) | ||
219 | #define MGA1064_OPT_SYS_CLK_MSK ( 0x03 << 0 ) | ||
220 | |||
221 | #define MGA1064_OPT_SYS_CLK_DIS ( 0x01 << 2 ) | ||
222 | #define MGA1064_OPT_G_CLK_DIV_1 ( 0x01 << 3 ) | ||
223 | #define MGA1064_OPT_M_CLK_DIV_1 ( 0x01 << 4 ) | ||
224 | |||
225 | #define MGA1064_OPT_SYS_PLL_PDN ( 0x01 << 5 ) | ||
226 | #define MGA1064_OPT_VGA_ION ( 0x01 << 8 ) | ||
227 | |||
228 | /* MGA registers in PCI config space */ | ||
229 | #define PCI_MGA_INDEX 0x44 | ||
230 | #define PCI_MGA_DATA 0x48 | ||
231 | #define PCI_MGA_OPTION2 0x50 | ||
232 | #define PCI_MGA_OPTION3 0x54 | ||
233 | |||
234 | #define RAMDAC_OFFSET 0x3c00 | ||
235 | |||
236 | /* TVP3026 direct registers */ | ||
237 | |||
238 | #define TVP3026_INDEX 0x00 | ||
239 | #define TVP3026_WADR_PAL 0x00 | ||
240 | #define TVP3026_COL_PAL 0x01 | ||
241 | #define TVP3026_PIX_RD_MSK 0x02 | ||
242 | #define TVP3026_RADR_PAL 0x03 | ||
243 | #define TVP3026_CUR_COL_ADDR 0x04 | ||
244 | #define TVP3026_CUR_COL_DATA 0x05 | ||
245 | #define TVP3026_DATA 0x0a | ||
246 | #define TVP3026_CUR_RAM 0x0b | ||
247 | #define TVP3026_CUR_XLOW 0x0c | ||
248 | #define TVP3026_CUR_XHI 0x0d | ||
249 | #define TVP3026_CUR_YLOW 0x0e | ||
250 | #define TVP3026_CUR_YHI 0x0f | ||
251 | |||
252 | /* TVP3026 indirect registers */ | ||
253 | |||
254 | #define TVP3026_SILICON_REV 0x01 | ||
255 | #define TVP3026_CURSOR_CTL 0x06 | ||
256 | #define TVP3026_LATCH_CTL 0x0f | ||
257 | #define TVP3026_TRUE_COLOR_CTL 0x18 | ||
258 | #define TVP3026_MUX_CTL 0x19 | ||
259 | #define TVP3026_CLK_SEL 0x1a | ||
260 | #define TVP3026_PAL_PAGE 0x1c | ||
261 | #define TVP3026_GEN_CTL 0x1d | ||
262 | #define TVP3026_MISC_CTL 0x1e | ||
263 | #define TVP3026_GEN_IO_CTL 0x2a | ||
264 | #define TVP3026_GEN_IO_DATA 0x2b | ||
265 | #define TVP3026_PLL_ADDR 0x2c | ||
266 | #define TVP3026_PIX_CLK_DATA 0x2d | ||
267 | #define TVP3026_MEM_CLK_DATA 0x2e | ||
268 | #define TVP3026_LOAD_CLK_DATA 0x2f | ||
269 | #define TVP3026_KEY_RED_LOW 0x32 | ||
270 | #define TVP3026_KEY_RED_HI 0x33 | ||
271 | #define TVP3026_KEY_GREEN_LOW 0x34 | ||
272 | #define TVP3026_KEY_GREEN_HI 0x35 | ||
273 | #define TVP3026_KEY_BLUE_LOW 0x36 | ||
274 | #define TVP3026_KEY_BLUE_HI 0x37 | ||
275 | #define TVP3026_KEY_CTL 0x38 | ||
276 | #define TVP3026_MCLK_CTL 0x39 | ||
277 | #define TVP3026_SENSE_TEST 0x3a | ||
278 | #define TVP3026_TEST_DATA 0x3b | ||
279 | #define TVP3026_CRC_LSB 0x3c | ||
280 | #define TVP3026_CRC_MSB 0x3d | ||
281 | #define TVP3026_CRC_CTL 0x3e | ||
282 | #define TVP3026_ID 0x3f | ||
283 | #define TVP3026_RESET 0xff | ||
284 | |||
285 | |||
286 | /* MGA1064 DAC Register file */ | ||
287 | /* MGA1064 direct registers */ | ||
288 | |||
289 | #define MGA1064_INDEX 0x00 | ||
290 | #define MGA1064_WADR_PAL 0x00 | ||
291 | #define MGA1064_COL_PAL 0x01 | ||
292 | #define MGA1064_PIX_RD_MSK 0x02 | ||
293 | #define MGA1064_RADR_PAL 0x03 | ||
294 | #define MGA1064_DATA 0x0a | ||
295 | |||
296 | #define MGA1064_CUR_XLOW 0x0c | ||
297 | #define MGA1064_CUR_XHI 0x0d | ||
298 | #define MGA1064_CUR_YLOW 0x0e | ||
299 | #define MGA1064_CUR_YHI 0x0f | ||
300 | |||
301 | /* MGA1064 indirect registers */ | ||
302 | #define MGA1064_CURSOR_BASE_ADR_LOW 0x04 | ||
303 | #define MGA1064_CURSOR_BASE_ADR_HI 0x05 | ||
304 | #define MGA1064_CURSOR_CTL 0x06 | ||
305 | #define MGA1064_CURSOR_COL0_RED 0x08 | ||
306 | #define MGA1064_CURSOR_COL0_GREEN 0x09 | ||
307 | #define MGA1064_CURSOR_COL0_BLUE 0x0a | ||
308 | |||
309 | #define MGA1064_CURSOR_COL1_RED 0x0c | ||
310 | #define MGA1064_CURSOR_COL1_GREEN 0x0d | ||
311 | #define MGA1064_CURSOR_COL1_BLUE 0x0e | ||
312 | |||
313 | #define MGA1064_CURSOR_COL2_RED 0x010 | ||
314 | #define MGA1064_CURSOR_COL2_GREEN 0x011 | ||
315 | #define MGA1064_CURSOR_COL2_BLUE 0x012 | ||
316 | |||
317 | #define MGA1064_VREF_CTL 0x018 | ||
318 | |||
319 | #define MGA1064_MUL_CTL 0x19 | ||
320 | #define MGA1064_MUL_CTL_8bits 0x0 | ||
321 | #define MGA1064_MUL_CTL_15bits 0x01 | ||
322 | #define MGA1064_MUL_CTL_16bits 0x02 | ||
323 | #define MGA1064_MUL_CTL_24bits 0x03 | ||
324 | #define MGA1064_MUL_CTL_32bits 0x04 | ||
325 | #define MGA1064_MUL_CTL_2G8V16bits 0x05 | ||
326 | #define MGA1064_MUL_CTL_G16V16bits 0x06 | ||
327 | #define MGA1064_MUL_CTL_32_24bits 0x07 | ||
328 | |||
329 | #define MGAGDAC_XVREFCTRL 0x18 | ||
330 | #define MGA1064_PIX_CLK_CTL 0x1a | ||
331 | #define MGA1064_PIX_CLK_CTL_CLK_DIS ( 0x01 << 2 ) | ||
332 | #define MGA1064_PIX_CLK_CTL_CLK_POW_DOWN ( 0x01 << 3 ) | ||
333 | #define MGA1064_PIX_CLK_CTL_SEL_PCI ( 0x00 << 0 ) | ||
334 | #define MGA1064_PIX_CLK_CTL_SEL_PLL ( 0x01 << 0 ) | ||
335 | #define MGA1064_PIX_CLK_CTL_SEL_EXT ( 0x02 << 0 ) | ||
336 | #define MGA1064_PIX_CLK_CTL_SEL_MSK ( 0x03 << 0 ) | ||
337 | |||
338 | #define MGA1064_GEN_CTL 0x1d | ||
339 | #define MGA1064_MISC_CTL 0x1e | ||
340 | #define MGA1064_MISC_CTL_DAC_POW_DN ( 0x01 << 0 ) | ||
341 | #define MGA1064_MISC_CTL_VGA ( 0x01 << 1 ) | ||
342 | #define MGA1064_MISC_CTL_DIS_CON ( 0x03 << 1 ) | ||
343 | #define MGA1064_MISC_CTL_MAFC ( 0x02 << 1 ) | ||
344 | #define MGA1064_MISC_CTL_VGA8 ( 0x01 << 3 ) | ||
345 | #define MGA1064_MISC_CTL_DAC_RAM_CS ( 0x01 << 4 ) | ||
346 | |||
347 | #define MGA1064_GEN_IO_CTL 0x2a | ||
348 | #define MGA1064_GEN_IO_DATA 0x2b | ||
349 | #define MGA1064_SYS_PLL_M 0x2c | ||
350 | #define MGA1064_SYS_PLL_N 0x2d | ||
351 | #define MGA1064_SYS_PLL_P 0x2e | ||
352 | #define MGA1064_SYS_PLL_STAT 0x2f | ||
353 | #define MGA1064_ZOOM_CTL 0x38 | ||
354 | #define MGA1064_SENSE_TST 0x3a | ||
355 | |||
356 | #define MGA1064_CRC_LSB 0x3c | ||
357 | #define MGA1064_CRC_MSB 0x3d | ||
358 | #define MGA1064_CRC_CTL 0x3e | ||
359 | #define MGA1064_COL_KEY_MSK_LSB 0x40 | ||
360 | #define MGA1064_COL_KEY_MSK_MSB 0x41 | ||
361 | #define MGA1064_COL_KEY_LSB 0x42 | ||
362 | #define MGA1064_COL_KEY_MSB 0x43 | ||
363 | #define MGA1064_PIX_PLLA_M 0x44 | ||
364 | #define MGA1064_PIX_PLLA_N 0x45 | ||
365 | #define MGA1064_PIX_PLLA_P 0x46 | ||
366 | #define MGA1064_PIX_PLLB_M 0x48 | ||
367 | #define MGA1064_PIX_PLLB_N 0x49 | ||
368 | #define MGA1064_PIX_PLLB_P 0x4a | ||
369 | #define MGA1064_PIX_PLLC_M 0x4c | ||
370 | #define MGA1064_PIX_PLLC_N 0x4d | ||
371 | #define MGA1064_PIX_PLLC_P 0x4e | ||
372 | |||
373 | #define MGA1064_PIX_PLL_STAT 0x4f | ||
374 | |||
375 | #endif | ||
376 | |||
diff --git a/apps/plugins/sdl/src/video/fbcon/riva_mmio.h b/apps/plugins/sdl/src/video/fbcon/riva_mmio.h deleted file mode 100644 index e9261677b1..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/riva_mmio.h +++ /dev/null | |||
@@ -1,449 +0,0 @@ | |||
1 | /***************************************************************************\ | ||
2 | |* *| | ||
3 | |* Copyright 1993-1999 NVIDIA, Corporation. All rights reserved. *| | ||
4 | |* *| | ||
5 | |* NOTICE TO USER: The source code is copyrighted under U.S. and *| | ||
6 | |* international laws. Users and possessors of this source code are *| | ||
7 | |* hereby granted a nonexclusive, royalty-free copyright license to *| | ||
8 | |* use this code in individual and commercial software. *| | ||
9 | |* *| | ||
10 | |* Any use of this source code must include, in the user documenta- *| | ||
11 | |* tion and internal comments to the code, notices to the end user *| | ||
12 | |* as follows: *| | ||
13 | |* *| | ||
14 | |* Copyright 1993-1999 NVIDIA, Corporation. All rights reserved. *| | ||
15 | |* *| | ||
16 | |* NVIDIA, CORPORATION MAKES NO REPRESENTATION ABOUT THE SUITABILITY *| | ||
17 | |* OF THIS SOURCE CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" *| | ||
18 | |* WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND. NVIDIA, CORPOR- *| | ||
19 | |* ATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOURCE CODE, *| | ||
20 | |* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGE- *| | ||
21 | |* MENT, AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL *| | ||
22 | |* NVIDIA, CORPORATION BE LIABLE FOR ANY SPECIAL, INDIRECT, INCI- *| | ||
23 | |* DENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RE- *| | ||
24 | |* SULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION *| | ||
25 | |* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF *| | ||
26 | |* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE CODE. *| | ||
27 | |* *| | ||
28 | |* U.S. Government End Users. This source code is a "commercial *| | ||
29 | |* item," as that term is defined at 48 C.F.R. 2.101 (OCT 1995), *| | ||
30 | |* consisting of "commercial computer software" and "commercial *| | ||
31 | |* computer software documentation," as such terms are used in *| | ||
32 | |* 48 C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Govern- *| | ||
33 | |* ment only as a commercial end item. Consistent with 48 C.F.R. *| | ||
34 | |* 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), *| | ||
35 | |* all U.S. Government End Users acquire the source code with only *| | ||
36 | |* those rights set forth herein. *| | ||
37 | |* *| | ||
38 | \***************************************************************************/ | ||
39 | |||
40 | #ifndef __RIVA_HW_H__ | ||
41 | #define __RIVA_HW_H__ | ||
42 | #define RIVA_SW_VERSION 0x00010003 | ||
43 | |||
44 | /* | ||
45 | * Typedefs to force certain sized values. | ||
46 | */ | ||
47 | typedef Uint8 U008; | ||
48 | typedef Uint16 U016; | ||
49 | typedef Uint32 U032; | ||
50 | |||
51 | /* | ||
52 | * HW access macros. | ||
53 | */ | ||
54 | #define NV_WR08(p,i,d) (((U008 *)(p))[i]=(d)) | ||
55 | #define NV_RD08(p,i) (((U008 *)(p))[i]) | ||
56 | #define NV_WR16(p,i,d) (((U016 *)(p))[(i)/2]=(d)) | ||
57 | #define NV_RD16(p,i) (((U016 *)(p))[(i)/2]) | ||
58 | #define NV_WR32(p,i,d) (((U032 *)(p))[(i)/4]=(d)) | ||
59 | #define NV_RD32(p,i) (((U032 *)(p))[(i)/4]) | ||
60 | #define VGA_WR08(p,i,d) NV_WR08(p,i,d) | ||
61 | #define VGA_RD08(p,i) NV_RD08(p,i) | ||
62 | |||
63 | /* | ||
64 | * Define supported architectures. | ||
65 | */ | ||
66 | #define NV_ARCH_03 0x03 | ||
67 | #define NV_ARCH_04 0x04 | ||
68 | #define NV_ARCH_10 0x10 | ||
69 | /***************************************************************************\ | ||
70 | * * | ||
71 | * FIFO registers. * | ||
72 | * * | ||
73 | \***************************************************************************/ | ||
74 | |||
75 | /* | ||
76 | * Raster OPeration. Windows style ROP3. | ||
77 | */ | ||
78 | typedef volatile struct | ||
79 | { | ||
80 | U032 reserved00[4]; | ||
81 | U016 FifoFree; | ||
82 | U016 Nop; | ||
83 | U032 reserved01[0x0BB]; | ||
84 | U032 Rop3; | ||
85 | } RivaRop; | ||
86 | /* | ||
87 | * 8X8 Monochrome pattern. | ||
88 | */ | ||
89 | typedef volatile struct | ||
90 | { | ||
91 | U032 reserved00[4]; | ||
92 | U016 FifoFree; | ||
93 | U016 Nop; | ||
94 | U032 reserved01[0x0BD]; | ||
95 | U032 Shape; | ||
96 | U032 reserved03[0x001]; | ||
97 | U032 Color0; | ||
98 | U032 Color1; | ||
99 | U032 Monochrome[2]; | ||
100 | } RivaPattern; | ||
101 | /* | ||
102 | * Scissor clip rectangle. | ||
103 | */ | ||
104 | typedef volatile struct | ||
105 | { | ||
106 | U032 reserved00[4]; | ||
107 | U016 FifoFree; | ||
108 | U016 Nop; | ||
109 | U032 reserved01[0x0BB]; | ||
110 | U032 TopLeft; | ||
111 | U032 WidthHeight; | ||
112 | } RivaClip; | ||
113 | /* | ||
114 | * 2D filled rectangle. | ||
115 | */ | ||
116 | typedef volatile struct | ||
117 | { | ||
118 | U032 reserved00[4]; | ||
119 | U016 FifoFree; | ||
120 | U016 Nop[1]; | ||
121 | U032 reserved01[0x0BC]; | ||
122 | U032 Color; | ||
123 | U032 reserved03[0x03E]; | ||
124 | U032 TopLeft; | ||
125 | U032 WidthHeight; | ||
126 | } RivaRectangle; | ||
127 | /* | ||
128 | * 2D screen-screen BLT. | ||
129 | */ | ||
130 | typedef volatile struct | ||
131 | { | ||
132 | U032 reserved00[4]; | ||
133 | U016 FifoFree; | ||
134 | U016 Nop; | ||
135 | U032 reserved01[0x0BB]; | ||
136 | U032 TopLeftSrc; | ||
137 | U032 TopLeftDst; | ||
138 | U032 WidthHeight; | ||
139 | } RivaScreenBlt; | ||
140 | /* | ||
141 | * 2D pixel BLT. | ||
142 | */ | ||
143 | typedef volatile struct | ||
144 | { | ||
145 | U032 reserved00[4]; | ||
146 | U016 FifoFree; | ||
147 | U016 Nop[1]; | ||
148 | U032 reserved01[0x0BC]; | ||
149 | U032 TopLeft; | ||
150 | U032 WidthHeight; | ||
151 | U032 WidthHeightIn; | ||
152 | U032 reserved02[0x03C]; | ||
153 | U032 Pixels; | ||
154 | } RivaPixmap; | ||
155 | /* | ||
156 | * Filled rectangle combined with monochrome expand. Useful for glyphs. | ||
157 | */ | ||
158 | typedef volatile struct | ||
159 | { | ||
160 | U032 reserved00[4]; | ||
161 | U016 FifoFree; | ||
162 | U016 Nop; | ||
163 | U032 reserved01[0x0BB]; | ||
164 | U032 reserved03[(0x040)-1]; | ||
165 | U032 Color1A; | ||
166 | struct | ||
167 | { | ||
168 | U032 TopLeft; | ||
169 | U032 WidthHeight; | ||
170 | } UnclippedRectangle[64]; | ||
171 | U032 reserved04[(0x080)-3]; | ||
172 | struct | ||
173 | { | ||
174 | U032 TopLeft; | ||
175 | U032 BottomRight; | ||
176 | } ClipB; | ||
177 | U032 Color1B; | ||
178 | struct | ||
179 | { | ||
180 | U032 TopLeft; | ||
181 | U032 BottomRight; | ||
182 | } ClippedRectangle[64]; | ||
183 | U032 reserved05[(0x080)-5]; | ||
184 | struct | ||
185 | { | ||
186 | U032 TopLeft; | ||
187 | U032 BottomRight; | ||
188 | } ClipC; | ||
189 | U032 Color1C; | ||
190 | U032 WidthHeightC; | ||
191 | U032 PointC; | ||
192 | U032 MonochromeData1C; | ||
193 | U032 reserved06[(0x080)+121]; | ||
194 | struct | ||
195 | { | ||
196 | U032 TopLeft; | ||
197 | U032 BottomRight; | ||
198 | } ClipD; | ||
199 | U032 Color1D; | ||
200 | U032 WidthHeightInD; | ||
201 | U032 WidthHeightOutD; | ||
202 | U032 PointD; | ||
203 | U032 MonochromeData1D; | ||
204 | U032 reserved07[(0x080)+120]; | ||
205 | struct | ||
206 | { | ||
207 | U032 TopLeft; | ||
208 | U032 BottomRight; | ||
209 | } ClipE; | ||
210 | U032 Color0E; | ||
211 | U032 Color1E; | ||
212 | U032 WidthHeightInE; | ||
213 | U032 WidthHeightOutE; | ||
214 | U032 PointE; | ||
215 | U032 MonochromeData01E; | ||
216 | } RivaBitmap; | ||
217 | /* | ||
218 | * 3D textured, Z buffered triangle. | ||
219 | */ | ||
220 | typedef volatile struct | ||
221 | { | ||
222 | U032 reserved00[4]; | ||
223 | U016 FifoFree; | ||
224 | U016 Nop; | ||
225 | U032 reserved01[0x0BC]; | ||
226 | U032 TextureOffset; | ||
227 | U032 TextureFormat; | ||
228 | U032 TextureFilter; | ||
229 | U032 FogColor; | ||
230 | /* This is a problem on LynxOS */ | ||
231 | #ifdef Control | ||
232 | #undef Control | ||
233 | #endif | ||
234 | U032 Control; | ||
235 | U032 AlphaTest; | ||
236 | U032 reserved02[0x339]; | ||
237 | U032 FogAndIndex; | ||
238 | U032 Color; | ||
239 | float ScreenX; | ||
240 | float ScreenY; | ||
241 | float ScreenZ; | ||
242 | float EyeM; | ||
243 | float TextureS; | ||
244 | float TextureT; | ||
245 | } RivaTexturedTriangle03; | ||
246 | typedef volatile struct | ||
247 | { | ||
248 | U032 reserved00[4]; | ||
249 | U016 FifoFree; | ||
250 | U016 Nop; | ||
251 | U032 reserved01[0x0BB]; | ||
252 | U032 ColorKey; | ||
253 | U032 TextureOffset; | ||
254 | U032 TextureFormat; | ||
255 | U032 TextureFilter; | ||
256 | U032 Blend; | ||
257 | /* This is a problem on LynxOS */ | ||
258 | #ifdef Control | ||
259 | #undef Control | ||
260 | #endif | ||
261 | U032 Control; | ||
262 | U032 FogColor; | ||
263 | U032 reserved02[0x39]; | ||
264 | struct | ||
265 | { | ||
266 | float ScreenX; | ||
267 | float ScreenY; | ||
268 | float ScreenZ; | ||
269 | float EyeM; | ||
270 | U032 Color; | ||
271 | U032 Specular; | ||
272 | float TextureS; | ||
273 | float TextureT; | ||
274 | } Vertex[16]; | ||
275 | U032 DrawTriangle3D; | ||
276 | } RivaTexturedTriangle05; | ||
277 | /* | ||
278 | * 2D line. | ||
279 | */ | ||
280 | typedef volatile struct | ||
281 | { | ||
282 | U032 reserved00[4]; | ||
283 | U016 FifoFree; | ||
284 | U016 Nop[1]; | ||
285 | U032 reserved01[0x0BC]; | ||
286 | U032 Color; /* source color 0304-0307*/ | ||
287 | U032 Reserved02[0x03e]; | ||
288 | struct { /* start aliased methods in array 0400- */ | ||
289 | U032 point0; /* y_x S16_S16 in pixels 0- 3*/ | ||
290 | U032 point1; /* y_x S16_S16 in pixels 4- 7*/ | ||
291 | } Lin[16]; /* end of aliased methods in array -047f*/ | ||
292 | struct { /* start aliased methods in array 0480- */ | ||
293 | U032 point0X; /* in pixels, 0 at left 0- 3*/ | ||
294 | U032 point0Y; /* in pixels, 0 at top 4- 7*/ | ||
295 | U032 point1X; /* in pixels, 0 at left 8- b*/ | ||
296 | U032 point1Y; /* in pixels, 0 at top c- f*/ | ||
297 | } Lin32[8]; /* end of aliased methods in array -04ff*/ | ||
298 | U032 PolyLin[32]; /* y_x S16_S16 in pixels 0500-057f*/ | ||
299 | struct { /* start aliased methods in array 0580- */ | ||
300 | U032 x; /* in pixels, 0 at left 0- 3*/ | ||
301 | U032 y; /* in pixels, 0 at top 4- 7*/ | ||
302 | } PolyLin32[16]; /* end of aliased methods in array -05ff*/ | ||
303 | struct { /* start aliased methods in array 0600- */ | ||
304 | U032 color; /* source color 0- 3*/ | ||
305 | U032 point; /* y_x S16_S16 in pixels 4- 7*/ | ||
306 | } ColorPolyLin[16]; /* end of aliased methods in array -067f*/ | ||
307 | } RivaLine; | ||
308 | /* | ||
309 | * 2D/3D surfaces | ||
310 | */ | ||
311 | typedef volatile struct | ||
312 | { | ||
313 | U032 reserved00[4]; | ||
314 | U016 FifoFree; | ||
315 | U016 Nop; | ||
316 | U032 reserved01[0x0BE]; | ||
317 | U032 Offset; | ||
318 | } RivaSurface; | ||
319 | typedef volatile struct | ||
320 | { | ||
321 | U032 reserved00[4]; | ||
322 | U016 FifoFree; | ||
323 | U016 Nop; | ||
324 | U032 reserved01[0x0BD]; | ||
325 | U032 Pitch; | ||
326 | U032 RenderBufferOffset; | ||
327 | U032 ZBufferOffset; | ||
328 | } RivaSurface3D; | ||
329 | |||
330 | /***************************************************************************\ | ||
331 | * * | ||
332 | * Virtualized RIVA H/W interface. * | ||
333 | * * | ||
334 | \***************************************************************************/ | ||
335 | |||
336 | struct _riva_hw_inst; | ||
337 | struct _riva_hw_state; | ||
338 | /* | ||
339 | * Virtialized chip interface. Makes RIVA 128 and TNT look alike. | ||
340 | */ | ||
341 | typedef struct _riva_hw_inst | ||
342 | { | ||
343 | /* | ||
344 | * Chip specific settings. | ||
345 | */ | ||
346 | U032 Architecture; | ||
347 | U032 Version; | ||
348 | U032 CrystalFreqKHz; | ||
349 | U032 RamAmountKBytes; | ||
350 | U032 MaxVClockFreqKHz; | ||
351 | U032 RamBandwidthKBytesPerSec; | ||
352 | U032 EnableIRQ; | ||
353 | U032 IO; | ||
354 | U032 VBlankBit; | ||
355 | U032 FifoFreeCount; | ||
356 | U032 FifoEmptyCount; | ||
357 | /* | ||
358 | * Non-FIFO registers. | ||
359 | */ | ||
360 | volatile U032 *PCRTC; | ||
361 | volatile U032 *PRAMDAC; | ||
362 | volatile U032 *PFB; | ||
363 | volatile U032 *PFIFO; | ||
364 | volatile U032 *PGRAPH; | ||
365 | volatile U032 *PEXTDEV; | ||
366 | volatile U032 *PTIMER; | ||
367 | volatile U032 *PMC; | ||
368 | volatile U032 *PRAMIN; | ||
369 | volatile U032 *FIFO; | ||
370 | volatile U032 *CURSOR; | ||
371 | volatile U032 *CURSORPOS; | ||
372 | volatile U032 *VBLANKENABLE; | ||
373 | volatile U032 *VBLANK; | ||
374 | volatile U008 *PCIO; | ||
375 | volatile U008 *PVIO; | ||
376 | volatile U008 *PDIO; | ||
377 | /* | ||
378 | * Common chip functions. | ||
379 | */ | ||
380 | int (*Busy)(struct _riva_hw_inst *); | ||
381 | void (*CalcStateExt)(struct _riva_hw_inst *,struct _riva_hw_state *,int,int,int,int,int,int,int,int,int,int,int,int,int); | ||
382 | void (*LoadStateExt)(struct _riva_hw_inst *,struct _riva_hw_state *); | ||
383 | void (*UnloadStateExt)(struct _riva_hw_inst *,struct _riva_hw_state *); | ||
384 | void (*SetStartAddress)(struct _riva_hw_inst *,U032); | ||
385 | void (*SetSurfaces2D)(struct _riva_hw_inst *,U032,U032); | ||
386 | void (*SetSurfaces3D)(struct _riva_hw_inst *,U032,U032); | ||
387 | int (*ShowHideCursor)(struct _riva_hw_inst *,int); | ||
388 | void (*LockUnlock)(struct _riva_hw_inst *, int); | ||
389 | /* | ||
390 | * Current extended mode settings. | ||
391 | */ | ||
392 | struct _riva_hw_state *CurrentState; | ||
393 | /* | ||
394 | * FIFO registers. | ||
395 | */ | ||
396 | RivaRop *Rop; | ||
397 | RivaPattern *Patt; | ||
398 | RivaClip *Clip; | ||
399 | RivaPixmap *Pixmap; | ||
400 | RivaScreenBlt *Blt; | ||
401 | RivaBitmap *Bitmap; | ||
402 | RivaLine *Line; | ||
403 | RivaTexturedTriangle03 *Tri03; | ||
404 | RivaTexturedTriangle05 *Tri05; | ||
405 | } RIVA_HW_INST; | ||
406 | /* | ||
407 | * Extended mode state information. | ||
408 | */ | ||
409 | typedef struct _riva_hw_state | ||
410 | { | ||
411 | U032 bpp; | ||
412 | U032 width; | ||
413 | U032 height; | ||
414 | U032 repaint0; | ||
415 | U032 repaint1; | ||
416 | U032 screen; | ||
417 | U032 pixel; | ||
418 | U032 horiz; | ||
419 | U032 arbitration0; | ||
420 | U032 arbitration1; | ||
421 | U032 vpll; | ||
422 | U032 pllsel; | ||
423 | U032 general; | ||
424 | U032 config; | ||
425 | U032 cursor0; | ||
426 | U032 cursor1; | ||
427 | U032 cursor2; | ||
428 | U032 offset0; | ||
429 | U032 offset1; | ||
430 | U032 offset2; | ||
431 | U032 offset3; | ||
432 | U032 pitch0; | ||
433 | U032 pitch1; | ||
434 | U032 pitch2; | ||
435 | U032 pitch3; | ||
436 | } RIVA_HW_STATE; | ||
437 | |||
438 | /* | ||
439 | * FIFO Free Count. Should attempt to yield processor if RIVA is busy. | ||
440 | */ | ||
441 | |||
442 | #define RIVA_FIFO_FREE(hwptr,cnt) \ | ||
443 | { \ | ||
444 | while (FifoFreeCount < (cnt)) \ | ||
445 | FifoFreeCount = hwptr->FifoFree >> 2; \ | ||
446 | FifoFreeCount -= (cnt); \ | ||
447 | } | ||
448 | #endif /* __RIVA_HW_H__ */ | ||
449 | |||
diff --git a/apps/plugins/sdl/src/video/fbcon/riva_regs.h b/apps/plugins/sdl/src/video/fbcon/riva_regs.h deleted file mode 100644 index 5324562ecd..0000000000 --- a/apps/plugins/sdl/src/video/fbcon/riva_regs.h +++ /dev/null | |||
@@ -1,43 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #ifndef _RIVA_REGS_H | ||
25 | #define _RIVA_REGS_H | ||
26 | |||
27 | /* This information comes from the XFree86 NVidia hardware driver */ | ||
28 | |||
29 | /* mapped_io register offsets */ | ||
30 | #define PGRAPH_OFFSET 0x00400000 | ||
31 | #define FIFO_OFFSET 0x00800000 | ||
32 | #define ROP_OFFSET FIFO_OFFSET+0x00000000 | ||
33 | #define CLIP_OFFSET FIFO_OFFSET+0x00002000 | ||
34 | #define PATT_OFFSET FIFO_OFFSET+0x00004000 | ||
35 | #define PIXMAP_OFFSET FIFO_OFFSET+0x00006000 | ||
36 | #define BLT_OFFSET FIFO_OFFSET+0x00008000 | ||
37 | #define BITMAP_OFFSET FIFO_OFFSET+0x0000A000 | ||
38 | #define LINE_OFFSET FIFO_OFFSET+0x0000C000 | ||
39 | #define TRI03_OFFSET FIFO_OFFSET+0x0000E000 | ||
40 | #define PCIO_OFFSET 0x00601000 | ||
41 | |||
42 | #endif /* _RIVA_REGS_H */ | ||
43 | |||