/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    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

*/

#include "SDL_config.h"

/* 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

#include <asm/page.h>           /* For definition of PAGE_SIZE */

#endif

#include <linux/vt.h>

#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"

/*#define FBCON_DEBUG*/

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

#define VGA16_FBCON_SUPPORT

#include <sys/io.h>             /* For ioperm() */

#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) */

static const SDL_Rect checkres[] = {

    {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}

};

static const struct

{

    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

};

/* 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 int FB_InitHWSurfaces(_THIS, SDL_Surface * screen, char *base,

                             int size);

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 void FB_WaitIdle(_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);

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

    }

    return ret;

}

/* FB driver bootstrap functions */

static int

FB_Available(void)

{

    int console = -1;

    /* 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 */

    this = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));

    if (this) {

        SDL_memset(this, 0, (sizeof *this));

        this->hidden = (struct SDL_PrivateVideoData *)

            SDL_malloc((sizeof *this->hidden));

    }

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

        SDL_OutOfMemory();

        if (this) {

            SDL_free(this);

        }

        return (0);

    }

    SDL_memset(this->hidden, 0, (sizeof *this->hidden));

    wait_vbl = FB_WaitVBL;

    wait_idle = FB_WaitIdle;

    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 {

        if (fgets(line, length, f) <= 0)

            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;

        if (SDL_strncmp(line, "geometry", 8) == 0)

            break;

    }

    while (1);

    SDL_sscanf(line, "geometry %d %d %d %d %d", &vinfo->xres, &vinfo->yres,

               &vinfo->xres_virtual, &vinfo->yres_virtual,

               &vinfo->bits_per_pixel);

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

        return 0;

    SDL_sscanf(line, "timings %d %d %d %d %d %d %d", &vinfo->pixclock,

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

        }

    }

    while (SDL_strncmp(line, "endmode", 7) != 0);

    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;

}

static int

FB_AddMode(_THIS, int index, unsigned int w, unsigned int h,

           int check_timings)

{

    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;

            }

        }

        if (!found_timing) {

#ifdef FBCON_DEBUG

            fprintf(stderr, "No valid timing line for mode %dx%d\n", w, h);

#endif

            return (0);

        }

    }

    /* Set up the new video mode rectangle */

    mode = (SDL_Rect *) SDL_malloc(sizeof *mode);

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

        SDL_realloc(SDL_modelist[index],

                    (1 + next_mode + 1) * sizeof(SDL_Rect *));

    if (SDL_modelist[index] == NULL) {

        SDL_OutOfMemory();

        SDL_nummodes[index] = 0;

        SDL_free(mode);

        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;

}

static void

FB_SortModes(_THIS)

{

    int i;

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

        if (SDL_nummodes[i] > 0) {

            SDL_qsort(SDL_modelist[i], SDL_nummodes[i],

                      sizeof *SDL_modelist[i], cmpmodes);

        }

    }

}

static int

FB_VideoInit(_THIS, SDL_PixelFormat * vformat)

{

    const int pagesize = SDL_getpagesize();

    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;

    FILE *modesdb;

    /* Initialize the library */

    SDL_fbdev = SDL_getenv("SDL_FBDEV");

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

    }

#if !SDL_THREADS_DISABLED

    /* 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;

        fb_accel = SDL_getenv("SDL_FBACCEL");

        if (fb_accel) {

            finfo.accel = SDL_atoi(fb_accel);

        }

    }

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

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

                     (((long) finfo.smem_start) & ~(pagesize - 1)));

    mapped_memlen = finfo.smem_len + mapped_offset;

    mapped_mem = do_mmap(NULL, mapped_memlen,

                         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;

        mapped_io = do_mmap(NULL, mapped_iolen, PROT_READ | PROT_WRITE,

                            MAP_SHARED, console_fd, mapped_memlen);

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

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

            mapped_io = NULL;

        }

    }

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

    current_w = vinfo.xres;

    current_h = vinfo.yres;

    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;

    }

    if (SDL_getenv("SDL_FB_BROKEN_MODES") != 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;

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

                w = vinfo.xres;

                h = vinfo.yres;

                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;

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

                w = checkres[j].w;

                h = checkres[j].h;

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

                }

            }

        }

    }

    /* Fill in our hardware acceleration capabilities */

    this->info.current_w = current_w;

    this->info.current_h = current_h;

    this->info.wm_available = 0;

    this->info.hw_available = 1;

    this->info.video_mem = finfo.smem_len / 1024;

    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;

        }

    }

    /* Enable mouse and keyboard support */

    if (FB_OpenKeyboard(this) < 0) {

        FB_VideoQuit(this);

        return (-1);

    }

    if (FB_OpenMouse(this) < 0) {

        const char *sdl_nomouse;

        sdl_nomouse = SDL_getenv("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);

    }

    current->format->palette->ncolors = 16;

    /* 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;

    current->pixels = SDL_malloc(current->h * current->pitch);

    /* 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)

{

    struct fb_fix_screeninfo finfo;

    struct fb_var_screeninfo vinfo;

    int i;

    Uint32 Rmask;

    Uint32 Gmask;

    Uint32 Bmask;

    char *surfaces_mem;

    int surfaces_len;

    /* Set the terminal into graphics mode */

    if (FB_EnterGraphicsMode(this) < 0) {

        return (NULL);

    }

    /* Restore the original palette */

    FB_RestorePalette(this);