This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

/* Framebuffer console based SDL video driver implementation.

*/

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/ioctl.h>

#include <sys/mman.h>

#ifndef HAVE_GETPAGESIZE

#endif

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "../SDL_sysvideo.h"

#include "../SDL_pixels_c.h"

#include "../../events/SDL_events_c.h"

#include "SDL_fbvideo.h"

#include "SDL_fbmouse_c.h"

#include "SDL_fbevents_c.h"

#include "SDL_fb3dfx.h"

#include "SDL_fbmatrox.h"

#include "SDL_fbriva.h"

#if defined(i386) && defined(FB_TYPE_VGA_PLANES)

#define VGA16_FBCON_SUPPORT

#ifndef FB_AUX_VGA_PLANES_VGA4

#define FB_AUX_VGA_PLANES_VGA4 0

#endif

static inline void outb (unsigned char value, unsigned short port)

{

__asm__ __volatile__ ("outb %b0,%w1"::"a" (value), "Nd" (port));

}

#endif /* FB_TYPE_VGA_PLANES */

/* A list of video resolutions that we query for (sorted largest to smallest) */

{ 0, 0, 1600, 1200 }, /* 16 bpp: 0x11E, or 286 */

{ 0, 0, 1408, 1056 }, /* 16 bpp: 0x19A, or 410 */

{ 0, 0, 1280, 1024 }, /* 16 bpp: 0x11A, or 282 */

{ 0, 0, 1152, 864 }, /* 16 bpp: 0x192, or 402 */

{ 0, 0, 1024, 768 }, /* 16 bpp: 0x117, or 279 */

{ 0, 0, 960, 720 }, /* 16 bpp: 0x18A, or 394 */

{ 0, 0, 800, 600 }, /* 16 bpp: 0x114, or 276 */

{ 0, 0, 768, 576 }, /* 16 bpp: 0x182, or 386 */

{ 0, 0, 720, 576 }, /* PAL */

{ 0, 0, 720, 480 }, /* NTSC */

{ 0, 0, 640, 480 }, /* 16 bpp: 0x111, or 273 */

{ 0, 0, 640, 400 }, /* 8 bpp: 0x100, or 256 */

{ 0, 0, 512, 384 },

{ 0, 0, 320, 240 },

{ 0, 0, 320, 200 }

};

int xres;

int yres;

int pixclock;

int left;

int right;

int upper;

int lower;

int hslen;

int vslen;

int sync;

int vmode;

} vesa_timings[] = {

#ifdef USE_VESA_TIMINGS /* Only tested on Matrox Millenium I */

{ 640, 400, 39771, 48, 16, 39, 8, 96, 2, 2, 0 }, /* 70 Hz */

{ 640, 480, 39683, 48, 16, 33, 10, 96, 2, 0, 0 }, /* 60 Hz */

{ 768, 576, 26101, 144, 16, 28, 6, 112, 4, 0, 0 }, /* 60 Hz */

{ 800, 600, 24038, 144, 24, 28, 8, 112, 6, 0, 0 }, /* 60 Hz */

{ 960, 720, 17686, 144, 24, 28, 8, 112, 4, 0, 0 }, /* 60 Hz */

{ 1024, 768, 15386, 160, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */

{ 1152, 864, 12286, 192, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */

{ 1280, 1024, 9369, 224, 32, 32, 4, 136, 4, 0, 0 }, /* 60 Hz */

{ 1408, 1056, 8214, 256, 40, 32, 5, 144, 5, 0, 0 }, /* 60 Hz */

{ 1600, 1200,/*?*/0, 272, 48, 32, 5, 152, 5, 0, 0 }, /* 60 Hz */

#else

/* You can generate these timings from your XF86Config file using

the 'modeline2fb' perl script included with the fbset package.

These timings were generated for Matrox Millenium I, 15" monitor.

*/

{ 320, 200, 79440, 16, 16, 20, 4, 48, 1, 0, 2 }, /* 70 Hz */

{ 320, 240, 63492, 16, 16, 16, 4, 48, 2, 0, 2 }, /* 72 Hz */

{ 512, 384, 49603, 48, 16, 16, 1, 64, 3, 0, 0 }, /* 78 Hz */

{ 640, 400, 31746, 96, 32, 41, 1, 64, 3, 2, 0 }, /* 85 Hz */

{ 640, 480, 31746, 120, 16, 16, 1, 64, 3, 0, 0 }, /* 75 Hz */

{ 768, 576, 26101, 144, 16, 28, 6, 112, 4, 0, 0 }, /* 60 Hz */

{ 800, 600, 20000, 64, 56, 23, 37, 120, 6, 3, 0 }, /* 72 Hz */

{ 960, 720, 17686, 144, 24, 28, 8, 112, 4, 0, 0 }, /* 60 Hz */

{ 1024, 768, 13333, 144, 24, 29, 3, 136, 6, 0, 0 }, /* 70 Hz */

{ 1152, 864, 12286, 192, 32, 30, 4, 128, 4, 0, 0 }, /* 60 Hz */

{ 1280, 1024, 9369, 224, 32, 32, 4, 136, 4, 0, 0 }, /* 60 Hz */

{ 1408, 1056, 8214, 256, 40, 32, 5, 144, 5, 0, 0 }, /* 60 Hz */

{ 1600, 1200,/*?*/0, 272, 48, 32, 5, 152, 5, 0, 0 }, /* 60 Hz */

#endif

};

enum {

FBCON_ROTATE_NONE = 0,

FBCON_ROTATE_CCW = 90,

FBCON_ROTATE_UD = 180,

FBCON_ROTATE_CW = 270

};

#define min(a,b) ((a)<(b)?(a):(b))

/* Initialization/Query functions */

static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat);

static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);

static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);

#ifdef VGA16_FBCON_SUPPORT

static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);

#endif

static int FB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);

static void FB_VideoQuit(_THIS);

/* Hardware surface functions */

static void FB_FreeHWSurfaces(_THIS);

static int FB_AllocHWSurface(_THIS, SDL_Surface *surface);

static int FB_LockHWSurface(_THIS, SDL_Surface *surface);

static void FB_UnlockHWSurface(_THIS, SDL_Surface *surface);

static void FB_FreeHWSurface(_THIS, SDL_Surface *surface);

static void FB_WaitVBL(_THIS);

static int FB_FlipHWSurface(_THIS, SDL_Surface *surface);

/* Internal palette functions */

static void FB_SavePalette(_THIS, struct fb_fix_screeninfo *finfo,

struct fb_var_screeninfo *vinfo);

static void FB_RestorePalette(_THIS);

/* Shadow buffer functions */

static FB_bitBlit FB_blit16;

static FB_bitBlit FB_blit16blocked;

static int SDL_getpagesize(void)

{

#ifdef HAVE_GETPAGESIZE

return getpagesize();

#elif defined(PAGE_SIZE)

return PAGE_SIZE;

#else

#error Can not determine system page size.

return 4096; /* this is what it USED to be in Linux... */

#endif

}

/* Small wrapper for mmap() so we can play nicely with no-mmu hosts

* (non-mmu hosts disallow the MAP_SHARED flag) */

static void *do_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)

{

void *ret;

ret = mmap(start, length, prot, flags, fd, offset);

if ( ret == (char *)-1 && (flags & MAP_SHARED) ) {

ret = mmap(start, length, prot,

(flags & ~MAP_SHARED) | MAP_PRIVATE, fd, offset);

}

}

/* FB driver bootstrap functions */

static int FB_Available(void)

{

/* Added check for /fb/0 (devfs) */

/* but - use environment variable first... if it fails, still check defaults */

int idx = 0;

const char *SDL_fbdevs[4] = { NULL, "/dev/fb0", "/dev/fb/0", NULL };

SDL_fbdevs[0] = SDL_getenv("SDL_FBDEV");

if( !SDL_fbdevs[0] )

idx++;

for( ; SDL_fbdevs[idx]; idx++ )

{

console = open(SDL_fbdevs[idx], O_RDWR, 0);

if ( console >= 0 ) {

close(console);

break;

}

}

return(console >= 0);

}

static void FB_DeleteDevice(SDL_VideoDevice *device)

{

SDL_free(device->hidden);

SDL_free(device);

}

static SDL_VideoDevice *FB_CreateDevice(int devindex)

{

SDL_VideoDevice *this;

/* Initialize all variables that we clean on shutdown */

}

if ( (this == NULL) || (this->hidden == NULL) ) {

SDL_OutOfMemory();

if ( this ) {

}

return(0);

}

mouse_fd = -1;

keyboard_fd = -1;

/* Set the function pointers */

this->VideoInit = FB_VideoInit;

this->ListModes = FB_ListModes;

this->SetVideoMode = FB_SetVideoMode;

this->SetColors = FB_SetColors;

this->UpdateRects = NULL;

this->VideoQuit = FB_VideoQuit;

this->AllocHWSurface = FB_AllocHWSurface;

this->CheckHWBlit = NULL;

this->FillHWRect = NULL;

this->SetHWColorKey = NULL;

this->SetHWAlpha = NULL;

this->LockHWSurface = FB_LockHWSurface;

this->UnlockHWSurface = FB_UnlockHWSurface;

this->FlipHWSurface = FB_FlipHWSurface;

this->FreeHWSurface = FB_FreeHWSurface;

this->SetCaption = NULL;

this->SetIcon = NULL;

this->IconifyWindow = NULL;

this->GrabInput = NULL;

this->GetWMInfo = NULL;

this->InitOSKeymap = FB_InitOSKeymap;

this->PumpEvents = FB_PumpEvents;

this->free = FB_DeleteDevice;

return this;

}

VideoBootStrap FBCON_bootstrap = {

"fbcon", "Linux Framebuffer Console",

FB_Available, FB_CreateDevice

};

#define FB_MODES_DB "/etc/fb.modes"

static int read_fbmodes_line(FILE*f, char* line, int length)

{

int blank;

char* c;

int i;

blank=0;

/* find a relevant line */

do

{

return 0;

c=line;

while(((*c=='\t')||(*c==' '))&&(*c!=0))

c++;

if ((*c=='\n')||(*c=='#')||(*c==0))

blank=1;

else

blank=0;

}

while(blank);

/* remove whitespace at the begining of the string */

i=0;

do

{

line[i]=c[i];

i++;

}

while(c[i]!=0);

return 1;

}

static int read_fbmodes_mode(FILE *f, struct fb_var_screeninfo *vinfo)

{

char line[1024];

char option[256];

/* Find a "geometry" */

do {

if (read_fbmodes_line(f, line, sizeof(line))==0)

return 0;

break;

}

while(1);

&vinfo->xres_virtual, &vinfo->yres_virtual, &vinfo->bits_per_pixel);

if (read_fbmodes_line(f, line, sizeof(line))==0)

return 0;

&vinfo->left_margin, &vinfo->right_margin, &vinfo->upper_margin,

&vinfo->lower_margin, &vinfo->hsync_len, &vinfo->vsync_len);

vinfo->sync=0;

vinfo->vmode=FB_VMODE_NONINTERLACED;

/* Parse misc options */

do {

if (read_fbmodes_line(f, line, sizeof(line))==0)

return 0;

if (SDL_strncmp(line,"hsync",5)==0) {

SDL_sscanf(line,"hsync %s",option);

if (SDL_strncmp(option,"high",4)==0)

vinfo->sync |= FB_SYNC_HOR_HIGH_ACT;

}

else if (SDL_strncmp(line,"vsync",5)==0) {

SDL_sscanf(line,"vsync %s",option);

if (SDL_strncmp(option,"high",4)==0)

vinfo->sync |= FB_SYNC_VERT_HIGH_ACT;

}

else if (SDL_strncmp(line,"csync",5)==0) {

SDL_sscanf(line,"csync %s",option);

if (SDL_strncmp(option,"high",4)==0)

vinfo->sync |= FB_SYNC_COMP_HIGH_ACT;

}

else if (SDL_strncmp(line,"extsync",5)==0) {

SDL_sscanf(line,"extsync %s",option);

if (SDL_strncmp(option,"true",4)==0)

vinfo->sync |= FB_SYNC_EXT;

}

else if (SDL_strncmp(line,"laced",5)==0) {

SDL_sscanf(line,"laced %s",option);

if (SDL_strncmp(option,"true",4)==0)

vinfo->vmode |= FB_VMODE_INTERLACED;

}

else if (SDL_strncmp(line,"double",6)==0) {

SDL_sscanf(line,"double %s",option);

if (SDL_strncmp(option,"true",4)==0)

vinfo->vmode |= FB_VMODE_DOUBLE;

}

}

return 1;

}

static int FB_CheckMode(_THIS, struct fb_var_screeninfo *vinfo,

int index, unsigned int *w, unsigned int *h)

{

int mode_okay;

mode_okay = 0;

vinfo->bits_per_pixel = (index+1)*8;

vinfo->xres = *w;

vinfo->xres_virtual = *w;

vinfo->yres = *h;

vinfo->yres_virtual = *h;

vinfo->activate = FB_ACTIVATE_TEST;

if ( ioctl(console_fd, FBIOPUT_VSCREENINFO, vinfo) == 0 ) {

#ifdef FBCON_DEBUG

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);

#endif

if ( (((vinfo->bits_per_pixel+7)/8)-1) == index ) {

*w = vinfo->xres;

*h = vinfo->yres;

mode_okay = 1;

}

}

return mode_okay;

}

{

SDL_Rect *mode;

int i;

int next_mode;

/* Check to see if we already have this mode */

if ( SDL_nummodes[index] > 0 ) {

mode = SDL_modelist[index][SDL_nummodes[index]-1];

if ( (mode->w == w) && (mode->h == h) ) {

#ifdef FBCON_DEBUG

fprintf(stderr, "We already have mode %dx%d at %d bytes per pixel\n", w, h, index+1);

#endif

return(0);

}

}

/* Only allow a mode if we have a valid timing for it */

if ( check_timings ) {

int found_timing = 0;

for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) {

if ( (w == vesa_timings[i].xres) &&

(h == vesa_timings[i].yres) && vesa_timings[i].pixclock ) {

found_timing = 1;

break;

}

return(0);

}

}

/* Set up the new video mode rectangle */

if ( mode == NULL ) {

SDL_OutOfMemory();

return(-1);

}

mode->x = 0;

mode->y = 0;

mode->w = w;

mode->h = h;

#ifdef FBCON_DEBUG

fprintf(stderr, "Adding mode %dx%d at %d bytes per pixel\n", w, h, index+1);

#endif

/* Allocate the new list of modes, and fill in the new mode */

next_mode = SDL_nummodes[index];

SDL_modelist[index] = (SDL_Rect **)

if ( SDL_modelist[index] == NULL ) {

SDL_OutOfMemory();

SDL_nummodes[index] = 0;

return(-1);

}

SDL_modelist[index][next_mode] = mode;

SDL_modelist[index][next_mode+1] = NULL;

SDL_nummodes[index]++;

return(0);

}

static int cmpmodes(const void *va, const void *vb)

{

const SDL_Rect *a = *(const SDL_Rect**)va;

const SDL_Rect *b = *(const SDL_Rect**)vb;

if ( a->h == b->h )

return b->w - a->w;

else

return b->h - a->h;

}

{

int i;

for ( i=0; i<NUM_MODELISTS; ++i ) {

if ( SDL_nummodes[i] > 0 ) {

}

}

}

static int FB_VideoInit(_THIS, SDL_PixelFormat *vformat)

{

struct fb_fix_screeninfo finfo;

struct fb_var_screeninfo vinfo;

int i, j;

int current_index;

unsigned int current_w;

unsigned int current_h;

const char *SDL_fbdev;

/* Initialize the library */

if ( SDL_fbdev == NULL ) {

SDL_fbdev = "/dev/fb0";

}

console_fd = open(SDL_fbdev, O_RDWR, 0);

if ( console_fd < 0 ) {

SDL_SetError("Unable to open %s", SDL_fbdev);

return(-1);

}

/* Create the hardware surface lock mutex */

hw_lock = SDL_CreateMutex();

if ( hw_lock == NULL ) {

SDL_SetError("Unable to create lock mutex");

FB_VideoQuit(this);

return(-1);

}

#endif

/* Get the type of video hardware */

if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) {

SDL_SetError("Couldn't get console hardware info");

FB_VideoQuit(this);

return(-1);

}

switch (finfo.type) {

case FB_TYPE_PACKED_PIXELS:

/* Supported, no worries.. */

break;

#ifdef VGA16_FBCON_SUPPORT

case FB_TYPE_VGA_PLANES:

/* VGA16 is supported, but that's it */

if ( finfo.type_aux == FB_AUX_VGA_PLANES_VGA4 ) {

if ( ioperm(0x3b4, 0x3df - 0x3b4 + 1, 1) < 0 ) {

SDL_SetError("No I/O port permissions");

FB_VideoQuit(this);

return(-1);

}

this->SetVideoMode = FB_SetVGA16Mode;

break;

}

/* Fall through to unsupported case */

#endif /* VGA16_FBCON_SUPPORT */

default:

SDL_SetError("Unsupported console hardware");

FB_VideoQuit(this);

return(-1);

}

switch (finfo.visual) {

case FB_VISUAL_TRUECOLOR:

case FB_VISUAL_PSEUDOCOLOR:

case FB_VISUAL_STATIC_PSEUDOCOLOR:

case FB_VISUAL_DIRECTCOLOR:

break;

default:

SDL_SetError("Unsupported console hardware");

FB_VideoQuit(this);

return(-1);

}

/* Check if the user wants to disable hardware acceleration */

{ const char *fb_accel;

}

}

/* Memory map the device, compensating for buggy PPC mmap() */

mapped_offset = (((long)finfo.smem_start) -

PROT_READ|PROT_WRITE, MAP_SHARED, console_fd, 0);

if ( mapped_mem == (char *)-1 ) {

SDL_SetError("Unable to memory map the video hardware");

mapped_mem = NULL;

FB_VideoQuit(this);

return(-1);

}

/* Determine the current screen depth */

if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) {

SDL_SetError("Couldn't get console pixel format");

FB_VideoQuit(this);

return(-1);

}

vformat->BitsPerPixel = vinfo.bits_per_pixel;

if ( vformat->BitsPerPixel < 8 ) {

/* Assuming VGA16, we handle this via a shadow framebuffer */

vformat->BitsPerPixel = 8;

}

for ( i=0; i<vinfo.red.length; ++i ) {

vformat->Rmask <<= 1;

vformat->Rmask |= (0x00000001<<vinfo.red.offset);

}

for ( i=0; i<vinfo.green.length; ++i ) {

vformat->Gmask <<= 1;

vformat->Gmask |= (0x00000001<<vinfo.green.offset);

}

for ( i=0; i<vinfo.blue.length; ++i ) {

vformat->Bmask <<= 1;

vformat->Bmask |= (0x00000001<<vinfo.blue.offset);

}

saved_vinfo = vinfo;

/* Save hardware palette, if needed */

FB_SavePalette(this, &finfo, &vinfo);

/* If the I/O registers are available, memory map them so we

can take advantage of any supported hardware acceleration.

*/

vinfo.accel_flags = 0; /* Temporarily reserve registers */

ioctl(console_fd, FBIOPUT_VSCREENINFO, &vinfo);

if ( finfo.accel && finfo.mmio_len ) {

mapped_iolen = finfo.mmio_len;

MAP_SHARED, console_fd, mapped_memlen);

if ( mapped_io == (char *)-1 ) {

/* Hmm, failed to memory map I/O registers */

mapped_io = NULL;

}

}

rotate = FBCON_ROTATE_NONE;

rotation = SDL_getenv("SDL_VIDEO_FBCON_ROTATION");

if (rotation != NULL) {

if (SDL_strlen(rotation) == 0) {

shadow_fb = 0;

rotate = FBCON_ROTATE_NONE;

#ifdef FBCON_DEBUG

printf("Not rotating, no shadow\n");

#endif

} else if (!SDL_strcmp(rotation, "NONE")) {

shadow_fb = 1;

rotate = FBCON_ROTATE_NONE;

#ifdef FBCON_DEBUG

printf("Not rotating, but still using shadow\n");

#endif

} else if (!SDL_strcmp(rotation, "CW")) {

shadow_fb = 1;

rotate = FBCON_ROTATE_CW;

#ifdef FBCON_DEBUG

printf("Rotating screen clockwise\n");

#endif

} else if (!SDL_strcmp(rotation, "CCW")) {

shadow_fb = 1;

rotate = FBCON_ROTATE_CCW;

#ifdef FBCON_DEBUG

printf("Rotating screen counter clockwise\n");

#endif

} else if (!SDL_strcmp(rotation, "UD")) {

shadow_fb = 1;

rotate = FBCON_ROTATE_UD;

#ifdef FBCON_DEBUG

printf("Rotating screen upside down\n");

#endif

} else {

SDL_SetError("\"%s\" is not a valid value for "

"SDL_VIDEO_FBCON_ROTATION", rotation);

return(-1);

}

}

if (rotate == FBCON_ROTATE_CW || rotate == FBCON_ROTATE_CCW) {

current_w = vinfo.yres;

current_h = vinfo.xres;

} else {

current_w = vinfo.xres;

current_h = vinfo.yres;

}

/* Query for the list of available video modes */

current_index = ((vinfo.bits_per_pixel+7)/8)-1;

modesdb = fopen(FB_MODES_DB, "r");

for ( i=0; i<NUM_MODELISTS; ++i ) {

SDL_nummodes[i] = 0;

SDL_modelist[i] = NULL;

}

FB_AddMode(this, current_index, current_w, current_h, 0);

} else if(modesdb) {

while ( read_fbmodes_mode(modesdb, &vinfo) ) {

for ( i=0; i<NUM_MODELISTS; ++i ) {

unsigned int w, h;

if (rotate == FBCON_ROTATE_CW || rotate == FBCON_ROTATE_CCW) {

w = vinfo.yres;

h = vinfo.xres;

} else {

w = vinfo.xres;

h = vinfo.yres;

}

/* See if we are querying for the current mode */

if ( i == current_index ) {

if ( (current_w > w) || (current_h > h) ) {

/* Only check once */

FB_AddMode(this, i, current_w, current_h, 0);

current_index = -1;

}

}

if ( FB_CheckMode(this, &vinfo, i, &w, &h) ) {

FB_AddMode(this, i, w, h, 0);

}

}

}

fclose(modesdb);

FB_SortModes(this);

} else {

for ( i=0; i<NUM_MODELISTS; ++i ) {

for ( j=0; j<(sizeof(checkres)/sizeof(checkres[0])); ++j ) {

unsigned int w, h;

if (rotate == FBCON_ROTATE_CW || rotate == FBCON_ROTATE_CCW) {

w = checkres[j].h;

h = checkres[j].w;

} else {

w = checkres[j].w;

h = checkres[j].h;

}

/* See if we are querying for the current mode */

if ( i == current_index ) {

if ( (current_w > w) || (current_h > h) ) {

/* Only check once */

current_index = -1;

}

}

if ( FB_CheckMode(this, &vinfo, i, &w, &h) ) {

}

}

}

}

this->info.current_w = current_w;

this->info.current_h = current_h;

this->info.hw_available = !shadow_fb;

this->info.video_mem = shadow_fb ? 0 : finfo.smem_len/1024;

/* Fill in our hardware acceleration capabilities */

if ( mapped_io ) {

switch (finfo.accel) {

case FB_ACCEL_MATROX_MGA2064W:

case FB_ACCEL_MATROX_MGA1064SG:

case FB_ACCEL_MATROX_MGA2164W:

case FB_ACCEL_MATROX_MGA2164W_AGP:

case FB_ACCEL_MATROX_MGAG100:

/*case FB_ACCEL_MATROX_MGAG200: G200 acceleration broken! */

case FB_ACCEL_MATROX_MGAG400:

#ifdef FBACCEL_DEBUG

printf("Matrox hardware accelerator!\n");

#endif

FB_MatroxAccel(this, finfo.accel);

break;

case FB_ACCEL_3DFX_BANSHEE:

#ifdef FBACCEL_DEBUG

printf("3DFX hardware accelerator!\n");

#endif

FB_3DfxAccel(this, finfo.accel);

break;

case FB_ACCEL_NV3:

case FB_ACCEL_NV4:

#ifdef FBACCEL_DEBUG

printf("NVidia hardware accelerator!\n");

#endif

FB_RivaAccel(this, finfo.accel);

break;

default:

#ifdef FBACCEL_DEBUG

printf("Unknown hardware accelerator.\n");

#endif

break;

}

}

if (shadow_fb) {

shadow_mem = (char *)SDL_malloc(mapped_memlen);

if (shadow_mem == NULL) {

SDL_SetError("No memory for shadow");

return (-1);

}

}

/* Enable mouse and keyboard support */

if ( FB_OpenKeyboard(this) < 0 ) {

FB_VideoQuit(this);

return(-1);

}

if ( FB_OpenMouse(this) < 0 ) {

const char *sdl_nomouse;

if ( ! sdl_nomouse ) {

SDL_SetError("Unable to open mouse");

FB_VideoQuit(this);

return(-1);

}

}

/* We're done! */

return(0);

}

static SDL_Rect **FB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)

{

return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]);

}

/* Various screen update functions available */

static void FB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);

#ifdef VGA16_FBCON_SUPPORT

static void FB_VGA16Update(_THIS, int numrects, SDL_Rect *rects);

#endif

#ifdef FBCON_DEBUG

static void print_vinfo(struct fb_var_screeninfo *vinfo)

{

fprintf(stderr, "Printing vinfo:\n");

fprintf(stderr, "\txres: %d\n", vinfo->xres);

fprintf(stderr, "\tyres: %d\n", vinfo->yres);

fprintf(stderr, "\txres_virtual: %d\n", vinfo->xres_virtual);

fprintf(stderr, "\tyres_virtual: %d\n", vinfo->yres_virtual);

fprintf(stderr, "\txoffset: %d\n", vinfo->xoffset);

fprintf(stderr, "\tyoffset: %d\n", vinfo->yoffset);

fprintf(stderr, "\tbits_per_pixel: %d\n", vinfo->bits_per_pixel);

fprintf(stderr, "\tgrayscale: %d\n", vinfo->grayscale);

fprintf(stderr, "\tnonstd: %d\n", vinfo->nonstd);

fprintf(stderr, "\tactivate: %d\n", vinfo->activate);

fprintf(stderr, "\theight: %d\n", vinfo->height);

fprintf(stderr, "\twidth: %d\n", vinfo->width);

fprintf(stderr, "\taccel_flags: %d\n", vinfo->accel_flags);

fprintf(stderr, "\tpixclock: %d\n", vinfo->pixclock);

fprintf(stderr, "\tleft_margin: %d\n", vinfo->left_margin);

fprintf(stderr, "\tright_margin: %d\n", vinfo->right_margin);

fprintf(stderr, "\tupper_margin: %d\n", vinfo->upper_margin);

fprintf(stderr, "\tlower_margin: %d\n", vinfo->lower_margin);

fprintf(stderr, "\thsync_len: %d\n", vinfo->hsync_len);

fprintf(stderr, "\tvsync_len: %d\n", vinfo->vsync_len);

fprintf(stderr, "\tsync: %d\n", vinfo->sync);

fprintf(stderr, "\tvmode: %d\n", vinfo->vmode);

fprintf(stderr, "\tred: %d/%d\n", vinfo->red.length, vinfo->red.offset);

fprintf(stderr, "\tgreen: %d/%d\n", vinfo->green.length, vinfo->green.offset);

fprintf(stderr, "\tblue: %d/%d\n", vinfo->blue.length, vinfo->blue.offset);

fprintf(stderr, "\talpha: %d/%d\n", vinfo->transp.length, vinfo->transp.offset);

}

static void print_finfo(struct fb_fix_screeninfo *finfo)

{

fprintf(stderr, "Printing finfo:\n");

fprintf(stderr, "\tsmem_start = %p\n", (char *)finfo->smem_start);

fprintf(stderr, "\tsmem_len = %d\n", finfo->smem_len);

fprintf(stderr, "\ttype = %d\n", finfo->type);

fprintf(stderr, "\ttype_aux = %d\n", finfo->type_aux);

fprintf(stderr, "\tvisual = %d\n", finfo->visual);

fprintf(stderr, "\txpanstep = %d\n", finfo->xpanstep);

fprintf(stderr, "\typanstep = %d\n", finfo->ypanstep);

fprintf(stderr, "\tywrapstep = %d\n", finfo->ywrapstep);

fprintf(stderr, "\tline_length = %d\n", finfo->line_length);

fprintf(stderr, "\tmmio_start = %p\n", (char *)finfo->mmio_start);

fprintf(stderr, "\tmmio_len = %d\n", finfo->mmio_len);

fprintf(stderr, "\taccel = %d\n", finfo->accel);

}

#endif

static int choose_fbmodes_mode(struct fb_var_screeninfo *vinfo)

{

int matched;

FILE *modesdb;

struct fb_var_screeninfo cinfo;

matched = 0;

modesdb = fopen(FB_MODES_DB, "r");

if ( modesdb ) {

/* Parse the mode definition file */

while ( read_fbmodes_mode(modesdb, &cinfo) ) {

if ( (vinfo->xres == cinfo.xres && vinfo->yres == cinfo.yres) &&

(!matched || (vinfo->bits_per_pixel == cinfo.bits_per_pixel)) ) {

vinfo->pixclock = cinfo.pixclock;

vinfo->left_margin = cinfo.left_margin;

vinfo->right_margin = cinfo.right_margin;

vinfo->upper_margin = cinfo.upper_margin;

vinfo->lower_margin = cinfo.lower_margin;

vinfo->hsync_len = cinfo.hsync_len;

vinfo->vsync_len = cinfo.vsync_len;

if ( matched ) {

break;

}

matched = 1;

}

}

fclose(modesdb);

}

return(matched);

}

static int choose_vesa_mode(struct fb_var_screeninfo *vinfo)

{

int matched;

int i;

/* Check for VESA timings */

matched = 0;

for ( i=0; i<(sizeof(vesa_timings)/sizeof(vesa_timings[0])); ++i ) {

if ( (vinfo->xres == vesa_timings[i].xres) &&

(vinfo->yres == vesa_timings[i].yres) ) {

#ifdef FBCON_DEBUG

fprintf(stderr, "Using VESA timings for %dx%d\n",

vinfo->xres, vinfo->yres);

#endif

if ( vesa_timings[i].pixclock ) {

vinfo->pixclock = vesa_timings[i].pixclock;

}

vinfo->left_margin = vesa_timings[i].left;

vinfo->right_margin = vesa_timings[i].right;

vinfo->upper_margin = vesa_timings[i].upper;

vinfo->lower_margin = vesa_timings[i].lower;

vinfo->hsync_len = vesa_timings[i].hslen;

vinfo->vsync_len = vesa_timings[i].vslen;

vinfo->sync = vesa_timings[i].sync;

vinfo->vmode = vesa_timings[i].vmode;

matched = 1;

break;

}

}

return(matched);

}

#ifdef VGA16_FBCON_SUPPORT

static SDL_Surface *FB_SetVGA16Mode(_THIS, SDL_Surface *current,

int width, int height, int bpp, Uint32 flags)

{

struct fb_fix_screeninfo finfo;

struct fb_var_screeninfo vinfo;

/* Set the terminal into graphics mode */

if ( FB_EnterGraphicsMode(this) < 0 ) {

return(NULL);

}

/* Restore the original palette */

FB_RestorePalette(this);

/* Set the video mode and get the final screen format */

if ( ioctl(console_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) {

SDL_SetError("Couldn't get console screen info");

return(NULL);

}

cache_vinfo = vinfo;

#ifdef FBCON_DEBUG

fprintf(stderr, "Printing actual vinfo:\n");

print_vinfo(&vinfo);

#endif

if ( ! SDL_ReallocFormat(current, bpp, 0, 0, 0, 0) ) {

return(NULL);

}

/* Get the fixed information about the console hardware.

This is necessary since finfo.line_length changes.

*/

if ( ioctl(console_fd, FBIOGET_FSCREENINFO, &finfo) < 0 ) {

SDL_SetError("Couldn't get console hardware info");

return(NULL);

}

#ifdef FBCON_DEBUG

fprintf(stderr, "Printing actual finfo:\n");

print_finfo(&finfo);

#endif

/* Save hardware palette, if needed */

FB_SavePalette(this, &finfo, &vinfo);

/* Set up the new mode framebuffer */

current->flags = SDL_FULLSCREEN;

current->w = vinfo.xres;

current->h = vinfo.yres;

current->pitch = current->w;

/* Set the update rectangle function */

this->UpdateRects = FB_VGA16Update;

/* We're done */

return(current);

}

#endif /* VGA16_FBCON_SUPPORT */

static SDL_Surface *FB_SetVideoMode(_THIS, SDL_Surface *current,

int width, int height, int bpp, Uint32 flags)

{