author | Sam Lantinga <slouken@libsdl.org> |
Wed, 03 Apr 2002 21:45:25 +0000 | |
changeset 330 | 5fed858d551c |
parent 297 | f6ffac90895c |
child 487 | 414d77a36716 |
permissions | -rw-r--r-- |
0 | 1 |
/* |
2 |
SDL - Simple DirectMedia Layer |
|
297
f6ffac90895c
Updated copyright information for 2002
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
3 |
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Sam Lantinga |
0 | 4 |
|
5 |
This library is free software; you can redistribute it and/or |
|
6 |
modify it under the terms of the GNU Library General Public |
|
7 |
License as published by the Free Software Foundation; either |
|
8 |
version 2 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 |
Library General Public License for more details. |
|
14 |
||
15 |
You should have received a copy of the GNU Library General Public |
|
16 |
License along with this library; if not, write to the Free |
|
17 |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
18 |
||
19 |
Sam Lantinga |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
133
diff
changeset
|
20 |
slouken@libsdl.org |
0 | 21 |
*/ |
22 |
||
23 |
#ifdef SAVE_RCSID |
|
24 |
static char rcsid = |
|
25 |
"@(#) $Id$"; |
|
26 |
#endif |
|
27 |
||
28 |
/* Framebuffer console based SDL video driver implementation. |
|
29 |
*/ |
|
30 |
||
31 |
#include <stdlib.h> |
|
32 |
#include <stdio.h> |
|
33 |
#include <string.h> |
|
34 |
#include <fcntl.h> |
|
35 |
#include <unistd.h> |
|
36 |
#include <sys/ioctl.h> |
|
37 |
#include <sys/mman.h> |
|
38 |
#include <asm/page.h> /* For definition of PAGE_SIZE */ |
|
39 |
||
40 |
#include "SDL.h" |
|
41 |
#include "SDL_error.h" |
|
42 |
#include "SDL_video.h" |
|
43 |
#include "SDL_mouse.h" |
|
44 |
#include "SDL_sysvideo.h" |
|
45 |
#include "SDL_pixels_c.h" |
|
46 |
#include "SDL_events_c.h" |
|
47 |
#include "SDL_fbvideo.h" |
|
48 |
#include "SDL_fbmouse_c.h" |
|
49 |
#include "SDL_fbevents_c.h" |
|
50 |
#include "SDL_fb3dfx.h" |
|
51 |
#include "SDL_fbmatrox.h" |
|
133
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
52 |
#include "SDL_fbriva.h" |
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
53 |
|
0 | 54 |
|
55 |
#if defined(i386) && defined(FB_TYPE_VGA_PLANES) |
|
56 |
#define VGA16_FBCON_SUPPORT |
|
57 |
#ifndef FB_AUX_VGA_PLANES_VGA4 |
|
58 |
#define FB_AUX_VGA_PLANES_VGA4 0 |
|
59 |
#endif |
|
60 |
static inline void outb (unsigned char value, unsigned short port) |
|
61 |
{ |
|
62 |
__asm__ __volatile__ ("outb %b0,%w1"::"a" (value), "Nd" (port)); |
|
63 |
} |
|
64 |
#endif /* FB_TYPE_VGA_PLANES */ |
|
65 |
||
66 |
/* A list of video resolutions that we query for (sorted largest to smallest) */ |
|
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
6
diff
changeset
|
67 |
static const SDL_Rect checkres[] = { |
0 | 68 |
{ 0, 0, 1600, 1200 }, /* 16 bpp: 0x11E, or 286 */ |
69 |
{ 0, 0, 1408, 1056 }, /* 16 bpp: 0x19A, or 410 */ |
|
70 |
{ 0, 0, 1280, 1024 }, /* 16 bpp: 0x11A, or 282 */ |
|
71 |
{ 0, 0, 1152, 864 }, /* 16 bpp: 0x192, or 402 */ |
|
72 |
{ 0, 0, 1024, 768 }, /* 16 bpp: 0x117, or 279 */ |
|
73 |
{ 0, 0, 960, 720 }, /* 16 bpp: 0x18A, or 394 */ |
|
74 |
{ 0, 0, 800, 600 }, /* 16 bpp: 0x114, or 276 */ |
|
75 |
{ 0, 0, 768, 576 }, /* 16 bpp: 0x182, or 386 */ |
|
330
5fed858d551c
Date: 03 Apr 2002 15:28:09 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
76 |
{ 0, 0, 720, 576 }, /* PAL */ |
5fed858d551c
Date: 03 Apr 2002 15:28:09 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
77 |
{ 0, 0, 720, 480 }, /* NTSC */ |
0 | 78 |
{ 0, 0, 640, 480 }, /* 16 bpp: 0x111, or 273 */ |
79 |
{ 0, 0, 640, 400 }, /* 8 bpp: 0x100, or 256 */ |
|
80 |
{ 0, 0, 512, 384 }, |
|
81 |
{ 0, 0, 320, 240 }, |
|
82 |
{ 0, 0, 320, 200 } |
|
83 |
}; |
|
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
6
diff
changeset
|
84 |
static const struct { |
0 | 85 |
int xres; |
86 |
int yres; |
|
87 |
int pixclock; |
|
88 |
int left; |
|
89 |
int right; |
|
90 |
int upper; |
|
91 |
int lower; |
|
92 |
int hslen; |
|
93 |
int vslen; |
|
94 |
int sync; |
|
95 |
int vmode; |
|
96 |
} vesa_timings[] = { |
|
97 |
#ifdef USE_VESA_TIMINGS /* Only tested on Matrox Millenium I */ |
|
98 |
{ 640, 400, 39771, 48, 16, 39, 8, 96, 2, 2, 0 }, /* 70 Hz */ |
|
99 |
{ 640, 480, 39683, 48, 16, 33, 10, 96, 2, 0, 0 }, /* 60 Hz */ |
|
100 |
{ 768, 576, 26101, 144, 16, 28, 6, 112, 4, 0, 0 }, /* 60 Hz */ |
|
101 |
{ 800, 600, 24038, 144, 24, 28, 8, 112, 6, 0, 0 }, /* 60 Hz */ |
|
102 |
{ 960, 720, 17686, 144, 24, 28, 8, 112, 4, 0, 0 }, /* 60 Hz */ |
|
103 |
{ 1024, 768, 15386, 160, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */ |
|
104 |
{ 1152, 864, 12286, 192, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */ |
|
105 |
{ 1280, 1024, 9369, 224, 32, 32, 4, 136, 4, 0, 0 }, /* 60 Hz */ |
|
106 |
{ 1408, 1056, 8214, 256, 40, 32, 5, 144, 5, 0, 0 }, /* 60 Hz */ |
|
107 |
{ 1600, 1200,/*?*/0, 272, 48, 32, 5, 152, 5, 0, 0 }, /* 60 Hz */ |
|
108 |
#else |
|
109 |
/* You can generate these timings from your XF86Config file using |
|
110 |
the 'modeline2fb' perl script included with the fbset package. |
|
111 |
These timings were generated for Matrox Millenium I, 15" monitor. |
|
112 |
*/ |
|
113 |
{ 320, 200, 79440, 16, 16, 20, 4, 48, 1, 0, 2 }, /* 70 Hz */ |
|
114 |
{ 320, 240, 63492, 16, 16, 16, 4, 48, 2, 0, 2 }, /* 72 Hz */ |
|
115 |
{ 512, 384, 49603, 48, 16, 16, 1, 64, 3, 0, 0 }, /* 78 Hz */ |
|
116 |
{ 640, 400, 31746, 96, 32, 41, 1, 64, 3, 2, 0 }, /* 85 Hz */ |
|
117 |
{ 640, 480, 31746, 120, 16, 16, 1, 64, 3, 0, 0 }, /* 75 Hz */ |
|
118 |
{ 768, 576, 26101, 144, 16, 28, 6, 112, 4, 0, 0 }, /* 60 Hz */ |
|
119 |
{ 800, 600, 20000, 64, 56, 23, 37, 120, 6, 3, 0 }, /* 72 Hz */ |
|
120 |
{ 960, 720, 17686, 144, 24, 28, 8, 112, 4, 0, 0 }, /* 60 Hz */ |
|
121 |
{ 1024, 768, 13333, 144, 24, 29, 3, 136, 6, 0, 0 }, /* 70 Hz */ |
|
122 |
{ 1152, 864, 12286, 192, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */ |
|
123 |
{ 1280, 1024, 9369, 224, 32, 32, 4, 136, 4, 0, 0 }, /* 60 Hz */ |
|
124 |
{ 1408, 1056, 8214, 256, 40, 32, 5, 144, 5, 0, 0 }, /* 60 Hz */ |
|
125 |
{ 1600, 1200,/*?*/0, 272, 48, 32, 5, 152, 5, 0, 0 }, /* 60 Hz */ |
|
126 |
#endif |
|
127 |
}; |
|
128 |
||
129 |
/* Initialization/Query functions */ |
|
130 |
static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat); |
|
131 |
static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); |
|
132 |
static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); |
|
133 |
#ifdef VGA16_FBCON_SUPPORT |
|
134 |
static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); |
|
135 |
#endif |
|
136 |
static int FB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); |
|
137 |
static void FB_VideoQuit(_THIS); |
|
138 |
||
139 |
/* Hardware surface functions */ |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
140 |
static int FB_InitHWSurfaces(_THIS, SDL_Surface *screen, char *base, int size); |
0 | 141 |
static void FB_FreeHWSurfaces(_THIS); |
142 |
static int FB_AllocHWSurface(_THIS, SDL_Surface *surface); |
|
143 |
static int FB_LockHWSurface(_THIS, SDL_Surface *surface); |
|
144 |
static void FB_UnlockHWSurface(_THIS, SDL_Surface *surface); |
|
145 |
static void FB_FreeHWSurface(_THIS, SDL_Surface *surface); |
|
146 |
static void FB_WaitVBL(_THIS); |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
147 |
static void FB_WaitIdle(_THIS); |
0 | 148 |
static int FB_FlipHWSurface(_THIS, SDL_Surface *surface); |
149 |
||
150 |
/* Internal palette functions */ |
|
151 |
static void FB_SavePalette(_THIS, struct fb_fix_screeninfo *finfo, |
|
152 |
struct fb_var_screeninfo *vinfo); |
|
153 |
static void FB_RestorePalette(_THIS); |
|
154 |
||
155 |
/* FB driver bootstrap functions */ |
|
156 |
||
157 |
static int FB_Available(void) |
|
158 |
{ |
|
159 |
int console; |
|
160 |
const char *SDL_fbdev; |
|
161 |
||
162 |
SDL_fbdev = getenv("SDL_FBDEV"); |
|
163 |
if ( SDL_fbdev == NULL ) { |
|
164 |
SDL_fbdev = "/dev/fb0"; |
|
165 |
} |
|
166 |
console = open(SDL_fbdev, O_RDWR, 0); |
|
167 |
if ( console >= 0 ) { |
|
168 |
close(console); |
|
169 |
} |
|
170 |
return(console >= 0); |
|
171 |
} |
|
172 |
||
173 |
static void FB_DeleteDevice(SDL_VideoDevice *device) |
|
174 |
{ |
|
175 |
free(device->hidden); |
|
176 |
free(device); |
|
177 |
} |
|
178 |
||
179 |
static SDL_VideoDevice *FB_CreateDevice(int devindex) |
|
180 |
{ |
|
181 |
SDL_VideoDevice *this; |
|
182 |
||
183 |
/* Initialize all variables that we clean on shutdown */ |
|
184 |
this = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); |
|
185 |
if ( this ) { |
|
186 |
memset(this, 0, (sizeof *this)); |
|
187 |
this->hidden = (struct SDL_PrivateVideoData *) |
|
188 |
malloc((sizeof *this->hidden)); |
|
189 |
} |
|
190 |
if ( (this == NULL) || (this->hidden == NULL) ) { |
|
191 |
SDL_OutOfMemory(); |
|
192 |
if ( this ) { |
|
193 |
free(this); |
|
194 |
} |
|
195 |
return(0); |
|
196 |
} |
|
197 |
memset(this->hidden, 0, (sizeof *this->hidden)); |
|
198 |
wait_vbl = FB_WaitVBL; |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
199 |
wait_idle = FB_WaitIdle; |
0 | 200 |
mouse_fd = -1; |
201 |
keyboard_fd = -1; |
|
202 |
||
203 |
/* Set the function pointers */ |
|
204 |
this->VideoInit = FB_VideoInit; |
|
205 |
this->ListModes = FB_ListModes; |
|
206 |
this->SetVideoMode = FB_SetVideoMode; |
|
207 |
this->SetColors = FB_SetColors; |
|
208 |
this->UpdateRects = NULL; |
|
209 |
this->VideoQuit = FB_VideoQuit; |
|
210 |
this->AllocHWSurface = FB_AllocHWSurface; |
|
211 |
this->CheckHWBlit = NULL; |
|
212 |
this->FillHWRect = NULL; |
|
213 |
this->SetHWColorKey = NULL; |
|
214 |
this->SetHWAlpha = NULL; |
|
215 |
this->LockHWSurface = FB_LockHWSurface; |
|
216 |
this->UnlockHWSurface = FB_UnlockHWSurface; |
|
217 |
this->FlipHWSurface = FB_FlipHWSurface; |
|
218 |
this->FreeHWSurface = FB_FreeHWSurface; |
|
219 |
this->SetCaption = NULL; |
|
220 |
this->SetIcon = NULL; |
|
221 |
this->IconifyWindow = NULL; |
|
222 |
this->GrabInput = NULL; |
|
223 |
this->GetWMInfo = NULL; |
|
224 |
this->InitOSKeymap = FB_InitOSKeymap; |
|
225 |
this->PumpEvents = FB_PumpEvents; |
|
226 |
||
227 |
this->free = FB_DeleteDevice; |
|
228 |
||
229 |
return this; |
|
230 |
} |
|
231 |
||
232 |
VideoBootStrap FBCON_bootstrap = { |
|
233 |
"fbcon", "Linux Framebuffer Console", |
|
234 |
FB_Available, FB_CreateDevice |
|
235 |
}; |
|
236 |
||
237 |
static int FB_CheckMode(_THIS, struct fb_var_screeninfo *vinfo, |
|
238 |
int index, unsigned int *w, unsigned int *h) |
|
239 |
{ |
|
240 |
int mode_okay; |
|
241 |
||
242 |
mode_okay = 0; |
|
243 |
vinfo->bits_per_pixel = (index+1)*8; |
|
244 |
vinfo->xres = *w; |
|
245 |
vinfo->xres_virtual = *w; |
|
246 |
vinfo->yres = *h; |
|
247 |
vinfo->yres_virtual = *h; |
|
248 |
vinfo->activate = FB_ACTIVATE_TEST; |
|
249 |
if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, vinfo) == 0 ) { |
|
250 |
#ifdef FBCON_DEBUG |
|
251 |
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); |
|
252 |
#endif |
|
253 |
if ( (((vinfo->bits_per_pixel+7)/8)-1) == index ) { |
|
254 |
*w = vinfo->xres; |
|
255 |
*h = vinfo->yres; |
|
256 |
mode_okay = 1; |
|
257 |
} |
|
258 |
} |
|
259 |
return mode_okay; |
|
260 |
} |
|
261 |
||
262 |
static int FB_AddMode(_THIS, int index, unsigned int w, unsigned int h) |
|
263 |
{ |
|
264 |
SDL_Rect *mode; |
|
265 |
int i; |
|
266 |
int next_mode; |
|
267 |
||
268 |
/* Check to see if we already have this mode */ |
|
269 |
if ( SDL_nummodes[index] > 0 ) { |
|
270 |
mode = SDL_modelist[index][SDL_nummodes[index]-1]; |
|
271 |
if ( (mode->w == w) && (mode->h == h) ) { |
|
272 |
#ifdef FBCON_DEBUG |
|
273 |
fprintf(stderr, "We already have mode %dx%d at %d bytes per pixel\n", w, h, index+1); |
|
274 |
#endif |
|
275 |
return(0); |
|
276 |
} |
|
277 |
} |
|
278 |
||
279 |
/* Only allow a mode if we have a valid timing for it */ |
|
6
332f458469f0
Fixed 320x200 video mode on framebuffer console
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
280 |
next_mode = -1; |
0 | 281 |
for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) { |
282 |
if ( (w == vesa_timings[i].xres) && |
|
283 |
(h == vesa_timings[i].yres) && vesa_timings[i].pixclock ) { |
|
284 |
next_mode = i; |
|
285 |
break; |
|
286 |
} |
|
287 |
} |
|
6
332f458469f0
Fixed 320x200 video mode on framebuffer console
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
288 |
if ( next_mode == -1 ) { |
0 | 289 |
#ifdef FBCON_DEBUG |
290 |
fprintf(stderr, "No valid timing line for mode %dx%d\n", w, h); |
|
291 |
#endif |
|
292 |
return(0); |
|
293 |
} |
|
294 |
||
295 |
/* Set up the new video mode rectangle */ |
|
296 |
mode = (SDL_Rect *)malloc(sizeof *mode); |
|
297 |
if ( mode == NULL ) { |
|
298 |
SDL_OutOfMemory(); |
|
299 |
return(-1); |
|
300 |
} |
|
301 |
mode->x = 0; |
|
302 |
mode->y = 0; |
|
303 |
mode->w = w; |
|
304 |
mode->h = h; |
|
305 |
#ifdef FBCON_DEBUG |
|
306 |
fprintf(stderr, "Adding mode %dx%d at %d bytes per pixel\n", w, h, index+1); |
|
307 |
#endif |
|
308 |
||
309 |
/* Allocate the new list of modes, and fill in the new mode */ |
|
310 |
next_mode = SDL_nummodes[index]; |
|
311 |
SDL_modelist[index] = (SDL_Rect **) |
|
312 |
realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); |
|
313 |
if ( SDL_modelist[index] == NULL ) { |
|
314 |
SDL_OutOfMemory(); |
|
315 |
SDL_nummodes[index] = 0; |
|
316 |
free(mode); |
|
317 |
return(-1); |
|
318 |
} |
|
319 |
SDL_modelist[index][next_mode] = mode; |
|
320 |
SDL_modelist[index][next_mode+1] = NULL; |
|
321 |
SDL_nummodes[index]++; |
|
322 |
||
323 |
return(0); |
|
324 |
} |
|
325 |
||
326 |
static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat) |
|
327 |
{ |
|
328 |
struct fb_fix_screeninfo finfo; |
|
329 |
struct fb_var_screeninfo vinfo; |
|
330 |
int i, j; |
|
331 |
int current_index; |
|
332 |
unsigned int current_w; |
|
333 |
unsigned int current_h; |
|
334 |
const char *SDL_fbdev; |
|
335 |
||
336 |
/* Initialize the library */ |
|
337 |
SDL_fbdev = getenv("SDL_FBDEV"); |
|
338 |
if ( SDL_fbdev == NULL ) { |
|
339 |
SDL_fbdev = "/dev/fb0"; |
|
340 |
} |
|
341 |
console_fd = open(SDL_fbdev, O_RDWR, 0); |
|
342 |
if ( console_fd < 0 ) { |
|
343 |
SDL_SetError("Unable to open %s", SDL_fbdev); |
|
344 |
return(-1); |
|
345 |
} |
|
346 |
||
347 |
#ifndef DISABLE_THREADS |
|
348 |
/* Create the hardware surface lock mutex */ |
|
349 |
hw_lock = SDL_CreateMutex(); |
|
350 |
if ( hw_lock == NULL ) { |
|
351 |
SDL_SetError("Unable to create lock mutex"); |
|
352 |
FB_VideoQuit(this); |
|
353 |
return(-1); |
|
354 |
} |
|
355 |
#endif |
|
356 |
||
357 |
/* Get the type of video hardware */ |
|
358 |
if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) { |
|
359 |
SDL_SetError("Couldn't get console hardware info"); |
|
360 |
FB_VideoQuit(this); |
|
361 |
return(-1); |
|
362 |
} |
|
363 |
switch (finfo.type) { |
|
364 |
case FB_TYPE_PACKED_PIXELS: |
|
365 |
/* Supported, no worries.. */ |
|
366 |
break; |
|
367 |
#ifdef VGA16_FBCON_SUPPORT |
|
368 |
case FB_TYPE_VGA_PLANES: |
|
369 |
/* VGA16 is supported, but that's it */ |
|
370 |
if ( finfo.type_aux == FB_AUX_VGA_PLANES_VGA4 ) { |
|
371 |
if ( ioperm(0x3b4, 0x3df - 0x3b4 + 1, 1) < 0 ) { |
|
372 |
SDL_SetError("No I/O port permissions"); |
|
373 |
FB_VideoQuit(this); |
|
374 |
return(-1); |
|
375 |
} |
|
376 |
this->SetVideoMode = FB_SetVGA16Mode; |
|
377 |
break; |
|
378 |
} |
|
379 |
/* Fall through to unsupported case */ |
|
380 |
#endif /* VGA16_FBCON_SUPPORT */ |
|
381 |
default: |
|
382 |
SDL_SetError("Unsupported console hardware"); |
|
383 |
FB_VideoQuit(this); |
|
384 |
return(-1); |
|
385 |
} |
|
386 |
switch (finfo.visual) { |
|
387 |
case FB_VISUAL_TRUECOLOR: |
|
388 |
case FB_VISUAL_PSEUDOCOLOR: |
|
389 |
case FB_VISUAL_STATIC_PSEUDOCOLOR: |
|
390 |
case FB_VISUAL_DIRECTCOLOR: |
|
391 |
break; |
|
392 |
default: |
|
393 |
SDL_SetError("Unsupported console hardware"); |
|
394 |
FB_VideoQuit(this); |
|
395 |
return(-1); |
|
396 |
} |
|
397 |
||
398 |
/* Check if the user wants to disable hardware acceleration */ |
|
399 |
{ const char *fb_accel; |
|
400 |
fb_accel = getenv("SDL_FBACCEL"); |
|
401 |
if ( fb_accel ) { |
|
402 |
finfo.accel = atoi(fb_accel); |
|
403 |
} |
|
404 |
} |
|
405 |
||
406 |
/* Memory map the device, compensating for buggy PPC mmap() */ |
|
407 |
mapped_offset = (((long)finfo.smem_start) - |
|
408 |
(((long)finfo.smem_start)&~(PAGE_SIZE-1))); |
|
409 |
mapped_memlen = finfo.smem_len+mapped_offset; |
|
410 |
mapped_mem = mmap(NULL, mapped_memlen, |
|
411 |
PROT_READ|PROT_WRITE, MAP_SHARED, console_fd, 0); |
|
412 |
if ( mapped_mem == (char *)-1 ) { |
|
413 |
SDL_SetError("Unable to memory map the video hardware"); |
|
414 |
mapped_mem = NULL; |
|
415 |
FB_VideoQuit(this); |
|
416 |
return(-1); |
|
417 |
} |
|
418 |
||
419 |
/* Determine the current screen depth */ |
|
420 |
if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) { |
|
421 |
SDL_SetError("Couldn't get console pixel format"); |
|
422 |
FB_VideoQuit(this); |
|
423 |
return(-1); |
|
424 |
} |
|
425 |
vformat->BitsPerPixel = vinfo.bits_per_pixel; |
|
426 |
if ( vformat->BitsPerPixel < 8 ) { |
|
427 |
/* Assuming VGA16, we handle this via a shadow framebuffer */ |
|
428 |
vformat->BitsPerPixel = 8; |
|
429 |
} |
|
430 |
for ( i=0; i<vinfo.red.length; ++i ) { |
|
431 |
vformat->Rmask <<= 1; |
|
432 |
vformat->Rmask |= (0x00000001<<vinfo.red.offset); |
|
433 |
} |
|
434 |
for ( i=0; i<vinfo.green.length; ++i ) { |
|
435 |
vformat->Gmask <<= 1; |
|
436 |
vformat->Gmask |= (0x00000001<<vinfo.green.offset); |
|
437 |
} |
|
438 |
for ( i=0; i<vinfo.blue.length; ++i ) { |
|
439 |
vformat->Bmask <<= 1; |
|
440 |
vformat->Bmask |= (0x00000001<<vinfo.blue.offset); |
|
441 |
} |
|
442 |
saved_vinfo = vinfo; |
|
443 |
||
444 |
/* Save hardware palette, if needed */ |
|
445 |
FB_SavePalette(this, &finfo, &vinfo); |
|
446 |
||
447 |
/* If the I/O registers are available, memory map them so we |
|
448 |
can take advantage of any supported hardware acceleration. |
|
449 |
*/ |
|
450 |
vinfo.accel_flags = 0; /* Temporarily reserve registers */ |
|
451 |
ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo); |
|
452 |
if ( finfo.accel && finfo.mmio_len ) { |
|
453 |
mapped_iolen = finfo.mmio_len; |
|
454 |
mapped_io = mmap(NULL, mapped_iolen, PROT_READ|PROT_WRITE, |
|
455 |
MAP_SHARED, console_fd, mapped_memlen); |
|
456 |
if ( mapped_io == (char *)-1 ) { |
|
457 |
/* Hmm, failed to memory map I/O registers */ |
|
458 |
mapped_io = NULL; |
|
459 |
} |
|
460 |
} |
|
461 |
||
462 |
/* Query for the list of available video modes */ |
|
463 |
current_w = vinfo.xres; |
|
464 |
current_h = vinfo.yres; |
|
465 |
current_index = ((vinfo.bits_per_pixel+7)/8)-1; |
|
466 |
for ( i=0; i<NUM_MODELISTS; ++i ) { |
|
467 |
SDL_nummodes[i] = 0; |
|
468 |
SDL_modelist[i] = NULL; |
|
469 |
for ( j=0; j<(sizeof(checkres)/sizeof(checkres[0])); ++j ) { |
|
470 |
unsigned int w, h; |
|
471 |
||
472 |
/* See if we are querying for the current mode */ |
|
473 |
w = checkres[j].w; |
|
474 |
h = checkres[j].h; |
|
475 |
if ( i == current_index ) { |
|
476 |
if ( (current_w > w) || (current_h > h) ) { |
|
477 |
/* Only check once */ |
|
478 |
FB_AddMode(this, i,current_w,current_h); |
|
479 |
current_index = -1; |
|
480 |
} |
|
481 |
} |
|
482 |
if ( FB_CheckMode(this, &vinfo, i, &w, &h) ) { |
|
483 |
FB_AddMode(this, i, w, h); |
|
484 |
} |
|
485 |
} |
|
486 |
} |
|
487 |
||
488 |
/* Fill in our hardware acceleration capabilities */ |
|
489 |
this->info.wm_available = 0; |
|
490 |
this->info.hw_available = 1; |
|
491 |
this->info.video_mem = finfo.smem_len/1024; |
|
492 |
if ( mapped_io ) { |
|
493 |
switch (finfo.accel) { |
|
494 |
case FB_ACCEL_MATROX_MGA2064W: |
|
495 |
case FB_ACCEL_MATROX_MGA1064SG: |
|
496 |
case FB_ACCEL_MATROX_MGA2164W: |
|
497 |
case FB_ACCEL_MATROX_MGA2164W_AGP: |
|
498 |
case FB_ACCEL_MATROX_MGAG100: |
|
499 |
/*case FB_ACCEL_MATROX_MGAG200: G200 acceleration broken! */ |
|
500 |
case FB_ACCEL_MATROX_MGAG400: |
|
501 |
#ifdef FBACCEL_DEBUG |
|
502 |
printf("Matrox hardware accelerator!\n"); |
|
503 |
#endif |
|
504 |
FB_MatroxAccel(this, finfo.accel); |
|
505 |
break; |
|
506 |
case FB_ACCEL_3DFX_BANSHEE: |
|
507 |
#ifdef FBACCEL_DEBUG |
|
508 |
printf("3DFX hardware accelerator!\n"); |
|
509 |
#endif |
|
510 |
FB_3DfxAccel(this, finfo.accel); |
|
511 |
break; |
|
133
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
512 |
case FB_ACCEL_NV3: |
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
513 |
case FB_ACCEL_NV4: |
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
514 |
#ifdef FBACCEL_DEBUG |
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
515 |
printf("NVidia hardware accelerator!\n"); |
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
516 |
#endif |
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
517 |
FB_RivaAccel(this, finfo.accel); |
5d4bafca35cd
Added support for hardware accelerated NVidia driver on framebuffer console
Sam Lantinga <slouken@libsdl.org>
parents:
106
diff
changeset
|
518 |
break; |
0 | 519 |
default: |
520 |
#ifdef FBACCEL_DEBUG |
|
521 |
printf("Unknown hardware accelerator.\n"); |
|
522 |
#endif |
|
523 |
break; |
|
524 |
} |
|
525 |
} |
|
526 |
||
527 |
/* Enable mouse and keyboard support */ |
|
528 |
if ( FB_OpenKeyboard(this) < 0 ) { |
|
529 |
FB_VideoQuit(this); |
|
530 |
return(-1); |
|
531 |
} |
|
532 |
if ( FB_OpenMouse(this) < 0 ) { |
|
533 |
const char *sdl_nomouse; |
|
534 |
||
535 |
sdl_nomouse = getenv("SDL_NOMOUSE"); |
|
536 |
if ( ! sdl_nomouse ) { |
|
537 |
SDL_SetError("Unable to open mouse"); |
|
538 |
FB_VideoQuit(this); |
|
539 |
return(-1); |
|
540 |
} |
|
541 |
} |
|
542 |
||
543 |
/* We're done! */ |
|
544 |
return(0); |
|
545 |
} |
|
546 |
||
547 |
static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) |
|
548 |
{ |
|
549 |
return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]); |
|
550 |
} |
|
551 |
||
552 |
/* Various screen update functions available */ |
|
553 |
static void FB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); |
|
554 |
#ifdef VGA16_FBCON_SUPPORT |
|
555 |
static void FB_VGA16Update(_THIS, int numrects, SDL_Rect *rects); |
|
556 |
#endif |
|
557 |
||
558 |
#ifdef FBCON_DEBUG |
|
559 |
static void print_vinfo(struct fb_var_screeninfo *vinfo) |
|
560 |
{ |
|
561 |
fprintf(stderr, "Printing vinfo:\n"); |
|
562 |
fprintf(stderr, "\txres: %d\n", vinfo->xres); |
|
563 |
fprintf(stderr, "\tyres: %d\n", vinfo->yres); |
|
564 |
fprintf(stderr, "\txres_virtual: %d\n", vinfo->xres_virtual); |
|
565 |
fprintf(stderr, "\tyres_virtual: %d\n", vinfo->yres_virtual); |
|
566 |
fprintf(stderr, "\txoffset: %d\n", vinfo->xoffset); |
|
567 |
fprintf(stderr, "\tyoffset: %d\n", vinfo->yoffset); |
|
568 |
fprintf(stderr, "\tbits_per_pixel: %d\n", vinfo->bits_per_pixel); |
|
569 |
fprintf(stderr, "\tgrayscale: %d\n", vinfo->grayscale); |
|
570 |
fprintf(stderr, "\tnonstd: %d\n", vinfo->nonstd); |
|
571 |
fprintf(stderr, "\tactivate: %d\n", vinfo->activate); |
|
572 |
fprintf(stderr, "\theight: %d\n", vinfo->height); |
|
573 |
fprintf(stderr, "\twidth: %d\n", vinfo->width); |
|
574 |
fprintf(stderr, "\taccel_flags: %d\n", vinfo->accel_flags); |
|
575 |
fprintf(stderr, "\tpixclock: %d\n", vinfo->pixclock); |
|
576 |
fprintf(stderr, "\tleft_margin: %d\n", vinfo->left_margin); |
|
577 |
fprintf(stderr, "\tright_margin: %d\n", vinfo->right_margin); |
|
578 |
fprintf(stderr, "\tupper_margin: %d\n", vinfo->upper_margin); |
|
579 |
fprintf(stderr, "\tlower_margin: %d\n", vinfo->lower_margin); |
|
580 |
fprintf(stderr, "\thsync_len: %d\n", vinfo->hsync_len); |
|
581 |
fprintf(stderr, "\tvsync_len: %d\n", vinfo->vsync_len); |
|
582 |
fprintf(stderr, "\tsync: %d\n", vinfo->sync); |
|
583 |
fprintf(stderr, "\tvmode: %d\n", vinfo->vmode); |
|
584 |
fprintf(stderr, "\tred: %d/%d\n", vinfo->red.length, vinfo->red.offset); |
|
585 |
fprintf(stderr, "\tgreen: %d/%d\n", vinfo->green.length, vinfo->green.offset); |
|
586 |
fprintf(stderr, "\tblue: %d/%d\n", vinfo->blue.length, vinfo->blue.offset); |
|
587 |
fprintf(stderr, "\talpha: %d/%d\n", vinfo->transp.length, vinfo->transp.offset); |
|
588 |
} |
|
589 |
static void print_finfo(struct fb_fix_screeninfo *finfo) |
|
590 |
{ |
|
591 |
fprintf(stderr, "Printing finfo:\n"); |
|
592 |
fprintf(stderr, "\tsmem_start = %p\n", (char *)finfo->smem_start); |
|
593 |
fprintf(stderr, "\tsmem_len = %d\n", finfo->smem_len); |
|
594 |
fprintf(stderr, "\ttype = %d\n", finfo->type); |
|
595 |
fprintf(stderr, "\ttype_aux = %d\n", finfo->type_aux); |
|
596 |
fprintf(stderr, "\tvisual = %d\n", finfo->visual); |
|
597 |
fprintf(stderr, "\txpanstep = %d\n", finfo->xpanstep); |
|
598 |
fprintf(stderr, "\typanstep = %d\n", finfo->ypanstep); |
|
599 |
fprintf(stderr, "\tywrapstep = %d\n", finfo->ywrapstep); |
|
600 |
fprintf(stderr, "\tline_length = %d\n", finfo->line_length); |
|
601 |
fprintf(stderr, "\tmmio_start = %p\n", (char *)finfo->mmio_start); |
|
602 |
fprintf(stderr, "\tmmio_len = %d\n", finfo->mmio_len); |
|
603 |
fprintf(stderr, "\taccel = %d\n", finfo->accel); |
|
604 |
} |
|
605 |
#endif |
|
606 |
||
607 |
static int choose_fbmodes_mode(struct fb_var_screeninfo *vinfo) |
|
608 |
{ |
|
609 |
int matched; |
|
610 |
FILE *fbmodes; |
|
611 |
||
612 |
matched = 0; |
|
613 |
fbmodes = fopen("/etc/fb.modes", "r"); |
|
614 |
if ( fbmodes ) { |
|
615 |
/* FIXME: Parse the mode definition file */ |
|
616 |
fclose(fbmodes); |
|
617 |
} |
|
618 |
return(matched); |
|
619 |
} |
|
620 |
||
621 |
static int choose_vesa_mode(struct fb_var_screeninfo *vinfo) |
|
622 |
{ |
|
623 |
int matched; |
|
624 |
int i; |
|
625 |
||
626 |
/* Check for VESA timings */ |
|
627 |
matched = 0; |
|
628 |
for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) { |
|
629 |
if ( (vinfo->xres == vesa_timings[i].xres) && |
|
630 |
(vinfo->yres == vesa_timings[i].yres) ) { |
|
631 |
#ifdef FBCON_DEBUG |
|
632 |
fprintf(stderr, "Using VESA timings for %dx%d\n", |
|
633 |
vinfo->xres, vinfo->yres); |
|
634 |
#endif |
|
635 |
if ( vesa_timings[i].pixclock ) { |
|
636 |
vinfo->pixclock = vesa_timings[i].pixclock; |
|
637 |
} |
|
638 |
vinfo->left_margin = vesa_timings[i].left; |
|
639 |
vinfo->right_margin = vesa_timings[i].right; |
|
640 |
vinfo->upper_margin = vesa_timings[i].upper; |
|
641 |
vinfo->lower_margin = vesa_timings[i].lower; |
|
642 |
vinfo->hsync_len = vesa_timings[i].hslen; |
|
643 |
vinfo->vsync_len = vesa_timings[i].vslen; |
|
644 |
vinfo->sync = vesa_timings[i].sync; |
|
645 |
vinfo->vmode = vesa_timings[i].vmode; |
|
646 |
matched = 1; |
|
647 |
break; |
|
648 |
} |
|
649 |
} |
|
650 |
return(matched); |
|
651 |
} |
|
652 |
||
653 |
#ifdef VGA16_FBCON_SUPPORT |
|
654 |
static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current, |
|
655 |
int width, int height, int bpp, Uint32 flags) |
|
656 |
{ |
|
657 |
struct fb_fix_screeninfo finfo; |
|
658 |
struct fb_var_screeninfo vinfo; |
|
659 |
||
660 |
/* Set the terminal into graphics mode */ |
|
661 |
if ( FB_EnterGraphicsMode(this) < 0 ) { |
|
662 |
return(NULL); |
|
663 |
} |
|
664 |
||
665 |
/* Restore the original palette */ |
|
666 |
FB_RestorePalette(this); |
|
667 |
||
668 |
/* Set the video mode and get the final screen format */ |
|
669 |
if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) { |
|
670 |
SDL_SetError("Couldn't get console screen info"); |
|
671 |
return(NULL); |
|
672 |
} |
|
673 |
cache_vinfo = vinfo; |
|
674 |
#ifdef FBCON_DEBUG |
|
675 |
fprintf(stderr, "Printing actual vinfo:\n"); |
|
676 |
print_vinfo(&vinfo); |
|
677 |
#endif |
|
678 |
if ( ! SDL_ReallocFormat(current, bpp, 0, 0, 0, 0) ) { |
|
679 |
return(NULL); |
|
680 |
} |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
681 |
current->format->palette->ncolors = 16; |
0 | 682 |
|
683 |
/* Get the fixed information about the console hardware. |
|
684 |
This is necessary since finfo.line_length changes. |
|
685 |
*/ |
|
686 |
if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) { |
|
687 |
SDL_SetError("Couldn't get console hardware info"); |
|
688 |
return(NULL); |
|
689 |
} |
|
690 |
#ifdef FBCON_DEBUG |
|
691 |
fprintf(stderr, "Printing actual finfo:\n"); |
|
692 |
print_finfo(&finfo); |
|
693 |
#endif |
|
694 |
||
695 |
/* Save hardware palette, if needed */ |
|
696 |
FB_SavePalette(this, &finfo, &vinfo); |
|
697 |
||
698 |
/* Set up the new mode framebuffer */ |
|
699 |
current->flags = SDL_FULLSCREEN; |
|
700 |
current->w = vinfo.xres; |
|
701 |
current->h = vinfo.yres; |
|
702 |
current->pitch = current->w; |
|
703 |
current->pixels = malloc(current->h*current->pitch); |
|
704 |
||
705 |
/* Set the update rectangle function */ |
|
706 |
this->UpdateRects = FB_VGA16Update; |
|
707 |
||
708 |
/* We're done */ |
|
709 |
return(current); |
|
710 |
} |
|
711 |
#endif /* VGA16_FBCON_SUPPORT */ |
|
712 |
||
713 |
static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current, |
|
714 |
int width, int height, int bpp, Uint32 flags) |
|
715 |
{ |
|
716 |
struct fb_fix_screeninfo finfo; |
|
717 |
struct fb_var_screeninfo vinfo; |
|
718 |
int i; |
|
719 |
Uint32 Rmask; |
|
720 |
Uint32 Gmask; |
|
721 |
Uint32 Bmask; |
|
722 |
char *surfaces_mem; |
|
723 |
int surfaces_len; |
|
724 |
||
725 |
/* Set the terminal into graphics mode */ |
|
726 |
if ( FB_EnterGraphicsMode(this) < 0 ) { |
|
727 |
return(NULL); |
|
728 |
} |
|
729 |
||
730 |
/* Restore the original palette */ |
|
731 |
FB_RestorePalette(this); |
|
732 |
||
733 |
/* Set the video mode and get the final screen format */ |
|
734 |
if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) { |
|
735 |
SDL_SetError("Couldn't get console screen info"); |
|
736 |
return(NULL); |
|
737 |
} |
|
738 |
#ifdef FBCON_DEBUG |
|
739 |
fprintf(stderr, "Printing original vinfo:\n"); |
|
740 |
print_vinfo(&vinfo); |
|
741 |
#endif |
|
742 |
if ( (vinfo.xres != width) || (vinfo.yres != height) || |
|
743 |
(vinfo.bits_per_pixel != bpp) || (flags & SDL_DOUBLEBUF) ) { |
|
744 |
vinfo.activate = FB_ACTIVATE_NOW; |
|
745 |
vinfo.accel_flags = 0; |
|
746 |
vinfo.bits_per_pixel = bpp; |
|
747 |
vinfo.xres = width; |
|
748 |
vinfo.xres_virtual = width; |
|
749 |
vinfo.yres = height; |
|
750 |
if ( flags & SDL_DOUBLEBUF ) { |
|
751 |
vinfo.yres_virtual = height*2; |
|
752 |
} else { |
|
753 |
vinfo.yres_virtual = height; |
|
754 |
} |
|
755 |
vinfo.xoffset = 0; |
|
756 |
vinfo.yoffset = 0; |
|
757 |
vinfo.red.length = vinfo.red.offset = 0; |
|
758 |
vinfo.green.length = vinfo.green.offset = 0; |
|
759 |
vinfo.blue.length = vinfo.blue.offset = 0; |
|
760 |
vinfo.transp.length = vinfo.transp.offset = 0; |
|
761 |
if ( ! choose_fbmodes_mode(&vinfo) ) { |
|
762 |
choose_vesa_mode(&vinfo); |
|
763 |
} |
|
764 |
#ifdef FBCON_DEBUG |
|
765 |
fprintf(stderr, "Printing wanted vinfo:\n"); |
|
766 |
print_vinfo(&vinfo); |
|
767 |
#endif |
|
768 |
if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0 ) { |
|
769 |
vinfo.yres_virtual = height; |
|
770 |
if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0 ) { |
|
771 |
SDL_SetError("Couldn't set console screen info"); |
|
772 |
return(NULL); |
|
773 |
} |
|
774 |
} |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
775 |
} else { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
776 |
int maxheight; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
777 |
|
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
778 |
/* Figure out how much video memory is available */ |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
779 |
if ( flags & SDL_DOUBLEBUF ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
780 |
maxheight = height*2; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
781 |
} else { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
782 |
maxheight = height; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
783 |
} |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
784 |
if ( vinfo.yres_virtual > maxheight ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
785 |
vinfo.yres_virtual = maxheight; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
786 |
} |
0 | 787 |
} |
788 |
cache_vinfo = vinfo; |
|
789 |
#ifdef FBCON_DEBUG |
|
790 |
fprintf(stderr, "Printing actual vinfo:\n"); |
|
791 |
print_vinfo(&vinfo); |
|
792 |
#endif |
|
793 |
Rmask = 0; |
|
794 |
for ( i=0; i<vinfo.red.length; ++i ) { |
|
795 |
Rmask <<= 1; |
|
796 |
Rmask |= (0x00000001<<vinfo.red.offset); |
|
797 |
} |
|
798 |
Gmask = 0; |
|
799 |
for ( i=0; i<vinfo.green.length; ++i ) { |
|
800 |
Gmask <<= 1; |
|
801 |
Gmask |= (0x00000001<<vinfo.green.offset); |
|
802 |
} |
|
803 |
Bmask = 0; |
|
804 |
for ( i=0; i<vinfo.blue.length; ++i ) { |
|
805 |
Bmask <<= 1; |
|
806 |
Bmask |= (0x00000001<<vinfo.blue.offset); |
|
807 |
} |
|
808 |
if ( ! SDL_ReallocFormat(current, vinfo.bits_per_pixel, |
|
809 |
Rmask, Gmask, Bmask, 0) ) { |
|
810 |
return(NULL); |
|
811 |
} |
|
812 |
||
813 |
/* Get the fixed information about the console hardware. |
|
814 |
This is necessary since finfo.line_length changes. |
|
815 |
*/ |
|
816 |
if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) { |
|
817 |
SDL_SetError("Couldn't get console hardware info"); |
|
818 |
return(NULL); |
|
819 |
} |
|
820 |
||
821 |
/* Save hardware palette, if needed */ |
|
822 |
FB_SavePalette(this, &finfo, &vinfo); |
|
823 |
||
824 |
/* Set up the new mode framebuffer */ |
|
825 |
current->flags = (SDL_FULLSCREEN|SDL_HWSURFACE); |
|
826 |
current->w = vinfo.xres; |
|
827 |
current->h = vinfo.yres; |
|
828 |
current->pitch = finfo.line_length; |
|
829 |
current->pixels = mapped_mem+mapped_offset; |
|
830 |
||
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
831 |
/* Set up the information for hardware surfaces */ |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
832 |
surfaces_mem = (char *)current->pixels + |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
833 |
vinfo.yres_virtual*current->pitch; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
834 |
surfaces_len = (mapped_memlen-(surfaces_mem-mapped_mem)); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
835 |
FB_FreeHWSurfaces(this); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
836 |
FB_InitHWSurfaces(this, current, surfaces_mem, surfaces_len); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
837 |
|
0 | 838 |
/* Let the application know we have a hardware palette */ |
839 |
switch (finfo.visual) { |
|
840 |
case FB_VISUAL_PSEUDOCOLOR: |
|
841 |
current->flags |= SDL_HWPALETTE; |
|
842 |
break; |
|
843 |
default: |
|
844 |
break; |
|
845 |
} |
|
846 |
||
847 |
/* Update for double-buffering, if we can */ |
|
848 |
if ( flags & SDL_DOUBLEBUF ) { |
|
849 |
if ( vinfo.yres_virtual == (height*2) ) { |
|
850 |
current->flags |= SDL_DOUBLEBUF; |
|
851 |
flip_page = 0; |
|
852 |
flip_address[0] = (char *)current->pixels; |
|
853 |
flip_address[1] = (char *)current->pixels+ |
|
854 |
current->h*current->pitch; |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
855 |
this->screen = current; |
0 | 856 |
FB_FlipHWSurface(this, current); |
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
857 |
this->screen = NULL; |
0 | 858 |
} |
859 |
} |
|
860 |
||
861 |
/* Set the update rectangle function */ |
|
862 |
this->UpdateRects = FB_DirectUpdate; |
|
863 |
||
864 |
/* We're done */ |
|
865 |
return(current); |
|
866 |
} |
|
867 |
||
868 |
#ifdef FBCON_DEBUG |
|
869 |
void FB_DumpHWSurfaces(_THIS) |
|
870 |
{ |
|
871 |
vidmem_bucket *bucket; |
|
872 |
||
873 |
printf("Memory left: %d (%d total)\n", surfaces_memleft, surfaces_memtotal); |
|
874 |
printf("\n"); |
|
875 |
printf(" Base Size\n"); |
|
876 |
for ( bucket=&surfaces; bucket; bucket=bucket->next ) { |
|
877 |
printf("Bucket: %p, %d (%s)\n", bucket->base, bucket->size, bucket->used ? "used" : "free"); |
|
878 |
if ( bucket->prev ) { |
|
879 |
if ( bucket->base != bucket->prev->base+bucket->prev->size ) { |
|
880 |
printf("Warning, corrupt bucket list! (prev)\n"); |
|
881 |
} |
|
882 |
} else { |
|
883 |
if ( bucket != &surfaces ) { |
|
884 |
printf("Warning, corrupt bucket list! (!prev)\n"); |
|
885 |
} |
|
886 |
} |
|
887 |
if ( bucket->next ) { |
|
888 |
if ( bucket->next->base != bucket->base+bucket->size ) { |
|
889 |
printf("Warning, corrupt bucket list! (next)\n"); |
|
890 |
} |
|
891 |
} |
|
892 |
} |
|
893 |
printf("\n"); |
|
894 |
} |
|
895 |
#endif |
|
896 |
||
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
897 |
static int FB_InitHWSurfaces(_THIS, SDL_Surface *screen, char *base, int size) |
0 | 898 |
{ |
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
899 |
vidmem_bucket *bucket; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
900 |
|
0 | 901 |
surfaces_memtotal = size; |
902 |
surfaces_memleft = size; |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
903 |
|
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
904 |
if ( surfaces_memleft > 0 ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
905 |
bucket = (vidmem_bucket *)malloc(sizeof(*bucket)); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
906 |
if ( bucket == NULL ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
907 |
SDL_OutOfMemory(); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
908 |
return(-1); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
909 |
} |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
910 |
bucket->prev = &surfaces; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
911 |
bucket->used = 0; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
912 |
bucket->dirty = 0; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
913 |
bucket->base = base; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
914 |
bucket->size = size; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
915 |
bucket->next = NULL; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
916 |
} else { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
917 |
bucket = NULL; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
918 |
} |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
919 |
|
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
920 |
surfaces.prev = NULL; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
921 |
surfaces.used = 1; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
922 |
surfaces.dirty = 0; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
923 |
surfaces.base = screen->pixels; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
924 |
surfaces.size = (unsigned int)((long)base - (long)surfaces.base); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
925 |
surfaces.next = bucket; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
926 |
screen->hwdata = (struct private_hwdata *)&surfaces; |
0 | 927 |
return(0); |
928 |
} |
|
929 |
static void FB_FreeHWSurfaces(_THIS) |
|
930 |
{ |
|
931 |
vidmem_bucket *bucket, *freeable; |
|
932 |
||
933 |
bucket = surfaces.next; |
|
934 |
while ( bucket ) { |
|
935 |
freeable = bucket; |
|
936 |
bucket = bucket->next; |
|
937 |
free(freeable); |
|
938 |
} |
|
939 |
surfaces.next = NULL; |
|
940 |
} |
|
941 |
||
942 |
static int FB_AllocHWSurface(_THIS, SDL_Surface *surface) |
|
943 |
{ |
|
944 |
vidmem_bucket *bucket; |
|
945 |
int size; |
|
946 |
int extra; |
|
947 |
||
948 |
/* Temporarily, we only allow surfaces the same width as display. |
|
949 |
Some blitters require the pitch between two hardware surfaces |
|
950 |
to be the same. Others have interesting alignment restrictions. |
|
951 |
Until someone who knows these details looks at the code... |
|
952 |
*/ |
|
953 |
if ( surface->pitch > SDL_VideoSurface->pitch ) { |
|
954 |
SDL_SetError("Surface requested wider than screen"); |
|
955 |
return(-1); |
|
956 |
} |
|
957 |
surface->pitch = SDL_VideoSurface->pitch; |
|
958 |
size = surface->h * surface->pitch; |
|
959 |
#ifdef FBCON_DEBUG |
|
960 |
fprintf(stderr, "Allocating bucket of %d bytes\n", size); |
|
961 |
#endif |
|
962 |
||
963 |
/* Quick check for available mem */ |
|
964 |
if ( size > surfaces_memleft ) { |
|
965 |
SDL_SetError("Not enough video memory"); |
|
966 |
return(-1); |
|
967 |
} |
|
968 |
||
969 |
/* Search for an empty bucket big enough */ |
|
970 |
for ( bucket=&surfaces; bucket; bucket=bucket->next ) { |
|
971 |
if ( ! bucket->used && (size <= bucket->size) ) { |
|
972 |
break; |
|
973 |
} |
|
974 |
} |
|
975 |
if ( bucket == NULL ) { |
|
976 |
SDL_SetError("Video memory too fragmented"); |
|
977 |
return(-1); |
|
978 |
} |
|
979 |
||
980 |
/* Create a new bucket for left-over memory */ |
|
981 |
extra = (bucket->size - size); |
|
982 |
if ( extra ) { |
|
983 |
vidmem_bucket *newbucket; |
|
984 |
||
985 |
#ifdef FBCON_DEBUG |
|
986 |
fprintf(stderr, "Adding new free bucket of %d bytes\n", extra); |
|
987 |
#endif |
|
988 |
newbucket = (vidmem_bucket *)malloc(sizeof(*newbucket)); |
|
989 |
if ( newbucket == NULL ) { |
|
990 |
SDL_OutOfMemory(); |
|
991 |
return(-1); |
|
992 |
} |
|
993 |
newbucket->prev = bucket; |
|
994 |
newbucket->used = 0; |
|
995 |
newbucket->base = bucket->base+size; |
|
996 |
newbucket->size = extra; |
|
997 |
newbucket->next = bucket->next; |
|
998 |
if ( bucket->next ) { |
|
999 |
bucket->next->prev = newbucket; |
|
1000 |
} |
|
1001 |
bucket->next = newbucket; |
|
1002 |
} |
|
1003 |
||
1004 |
/* Set the current bucket values and return it! */ |
|
1005 |
bucket->used = 1; |
|
1006 |
bucket->size = size; |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1007 |
bucket->dirty = 0; |
0 | 1008 |
#ifdef FBCON_DEBUG |
1009 |
fprintf(stderr, "Allocated %d bytes at %p\n", bucket->size, bucket->base); |
|
1010 |
#endif |
|
1011 |
surfaces_memleft -= size; |
|
1012 |
surface->flags |= SDL_HWSURFACE; |
|
1013 |
surface->pixels = bucket->base; |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1014 |
surface->hwdata = (struct private_hwdata *)bucket; |
0 | 1015 |
return(0); |
1016 |
} |
|
1017 |
static void FB_FreeHWSurface(_THIS, SDL_Surface *surface) |
|
1018 |
{ |
|
1019 |
vidmem_bucket *bucket, *freeable; |
|
1020 |
||
1021 |
/* Look for the bucket in the current list */ |
|
1022 |
for ( bucket=&surfaces; bucket; bucket=bucket->next ) { |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1023 |
if ( bucket == (vidmem_bucket *)surface->hwdata ) { |
0 | 1024 |
break; |
1025 |
} |
|
1026 |
} |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1027 |
if ( bucket && bucket->used ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1028 |
/* Add the memory back to the total */ |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1029 |
#ifdef DGA_DEBUG |
0 | 1030 |
printf("Freeing bucket of %d bytes\n", bucket->size); |
1031 |
#endif |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1032 |
surfaces_memleft += bucket->size; |
0 | 1033 |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1034 |
/* Can we merge the space with surrounding buckets? */ |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1035 |
bucket->used = 0; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1036 |
if ( bucket->next && ! bucket->next->used ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1037 |
#ifdef DGA_DEBUG |
0 | 1038 |
printf("Merging with next bucket, for %d total bytes\n", bucket->size+bucket->next->size); |
1039 |
#endif |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1040 |
freeable = bucket->next; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1041 |
bucket->size += bucket->next->size; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1042 |
bucket->next = bucket->next->next; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1043 |
if ( bucket->next ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1044 |
bucket->next->prev = bucket; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1045 |
} |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1046 |
free(freeable); |
0 | 1047 |
} |
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1048 |
if ( bucket->prev && ! bucket->prev->used ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1049 |
#ifdef DGA_DEBUG |
0 | 1050 |
printf("Merging with previous bucket, for %d total bytes\n", bucket->prev->size+bucket->size); |
1051 |
#endif |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1052 |
freeable = bucket; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1053 |
bucket->prev->size += bucket->size; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1054 |
bucket->prev->next = bucket->next; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1055 |
if ( bucket->next ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1056 |
bucket->next->prev = bucket->prev; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1057 |
} |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1058 |
free(freeable); |
0 | 1059 |
} |
1060 |
} |
|
1061 |
surface->pixels = NULL; |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1062 |
surface->hwdata = NULL; |
0 | 1063 |
} |
1064 |
static int FB_LockHWSurface(_THIS, SDL_Surface *surface) |
|
1065 |
{ |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1066 |
if ( surface == this->screen ) { |
0 | 1067 |
SDL_mutexP(hw_lock); |
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1068 |
if ( FB_IsSurfaceBusy(surface) ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1069 |
FB_WaitBusySurfaces(this); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1070 |
} |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1071 |
} else { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1072 |
if ( FB_IsSurfaceBusy(surface) ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1073 |
FB_WaitBusySurfaces(this); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1074 |
} |
0 | 1075 |
} |
1076 |
return(0); |
|
1077 |
} |
|
1078 |
static void FB_UnlockHWSurface(_THIS, SDL_Surface *surface) |
|
1079 |
{ |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1080 |
if ( surface == this->screen ) { |
0 | 1081 |
SDL_mutexV(hw_lock); |
1082 |
} |
|
1083 |
} |
|
1084 |
||
1085 |
static void FB_WaitVBL(_THIS) |
|
1086 |
{ |
|
1087 |
#ifdef FBIOWAITRETRACE /* Heheh, this didn't make it into the main kernel */ |
|
1088 |
ioctl(console_fd, FBIOWAITRETRACE, 0); |
|
1089 |
#endif |
|
1090 |
return; |
|
1091 |
} |
|
1092 |
||
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1093 |
static void FB_WaitIdle(_THIS) |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1094 |
{ |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1095 |
return; |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1096 |
} |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1097 |
|
0 | 1098 |
static int FB_FlipHWSurface(_THIS, SDL_Surface *surface) |
1099 |
{ |
|
1100 |
/* Wait for vertical retrace and then flip display */ |
|
1101 |
cache_vinfo.yoffset = flip_page*surface->h; |
|
106
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1102 |
if ( FB_IsSurfaceBusy(this->screen) ) { |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1103 |
FB_WaitBusySurfaces(this); |
63ec24e0575f
Merged DGA video surface handling improvements, unified locking code.
Sam Lantinga <slouken@lokigames.com>
parents:
91
diff
changeset
|
1104 |
} |
0 | 1105 |
wait_vbl(this); |
1106 |
if ( ioctl(console_fd, FBIOPAN_DISPLAY, &cache_vinfo) < 0 ) { |
|
1107 |
SDL_SetError("ioctl(FBIOPAN_DISPLAY) failed"); |
|
1108 |
return(-1); |
|
1109 |
} |
|
1110 |
flip_page = !flip_page; |
|
1111 |
||
1112 |
surface->pixels = flip_address[flip_page]; |
|
1113 |
return(0); |
|
1114 |
} |
|
1115 |
||
1116 |
static void FB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) |
|
1117 |
{ |
|
1118 |
/* The application is already updating the visible video memory */ |
|
1119 |
return; |
|
1120 |
} |
|
1121 |
||
1122 |
#ifdef VGA16_FBCON_SUPPORT |
|
1123 |
/* Code adapted with thanks from the XFree86 VGA16 driver! :) */ |
|
1124 |
#define writeGr(index, value) \ |
|
1125 |
outb(index, 0x3CE); \ |
|
1126 |
outb(value, 0x3CF); |
|
1127 |
#define writeSeq(index, value) \ |
|
1128 |
outb(index, 0x3C4); \ |
|
1129 |
outb(value, 0x3C5); |
|
1130 |
||
1131 |
static void FB_VGA16Update(_THIS, int numrects, SDL_Rect *rects) |
|
1132 |
{ |
|
1133 |
SDL_Surface *screen; |
|
1134 |
int width, height, FBPitch, left, i, j, SRCPitch, phase; |
|
1135 |
register Uint32 m; |
|
1136 |
Uint8 s1, s2, s3, s4; |
|
1137 |
Uint32 *src, *srcPtr; |
|
1138 |
Uint8 *dst, *dstPtr; |
|
1139 |
||
1140 |
screen = this->screen; |
|
1141 |
FBPitch = screen->w >> 3; |
|
1142 |
SRCPitch = screen->pitch >> 2; |
|
1143 |
||
1144 |
writeGr(0x03, 0x00); |
|
1145 |
writeGr(0x05, 0x00); |
|
1146 |
writeGr(0x01, 0x00); |
|
1147 |
writeGr(0x08, 0xFF); |
|
1148 |
||
1149 |
while(numrects--) { |
|
1150 |
left = rects->x & ~7; |
|
1151 |
width = (rects->w + 7) >> 3; |
|
1152 |
height = rects->h; |
|
1153 |
src = (Uint32*)screen->pixels + (rects->y * SRCPitch) + (left >> 2); |
|
1154 |
dst = (Uint8*)mapped_mem + (rects->y * FBPitch) + (left >> 3); |
|
1155 |
||
1156 |
if((phase = (long)dst & 3L)) { |
|
1157 |
phase = 4 - phase; |
|
1158 |
if(phase > width) phase = width; |
|
1159 |
width -= phase; |
|
1160 |
} |
|
1161 |
||
1162 |
while(height--) { |
|
1163 |
writeSeq(0x02, 1 << 0); |
|
1164 |
dstPtr = dst; |
|
1165 |
srcPtr = src; |
|
1166 |
i = width; |
|
1167 |
j = phase; |
|
1168 |
while(j--) { |
|
1169 |
m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4); |
|
1170 |
*dstPtr++ = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); |
|
1171 |
srcPtr += 2; |
|
1172 |
} |
|
1173 |
while(i >= 4) { |
|
1174 |
m = (srcPtr[1] & 0x01010101) | ((srcPtr[0] & 0x01010101) << 4); |
|
1175 |
s1 = (m >> 24) | (m >> 15) | (m >> 6) | (m << 3); |
|
1176 |
m = (srcPtr[3] & 0x01010101) | ((srcPtr[2] & 0x01010101) << 4); |
|
74212992fb08
Initial revision
Sam |