Merge branch 'linux-2.6'

1 files changed, 1487 insertions, 1314 deletions

diff --git a/drivers/video/atafb.c b/drivers/video/atafb.c
index bffe2b946344..0038a0541c7e 100644
--- a/drivers/video/atafb.c
+++ b/drivers/video/atafb.c
@@ -2,7 +2,7 @@
  * linux/drivers/video/atafb.c -- Atari builtin chipset frame buffer device
  *
  *  Copyright (C) 1994 Martin Schaller & Roman Hodek
- *  
+ *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file COPYING in the main directory of this archive
  * for more details.
@@ -70,14 +70,8 @@
 #include <linux/fb.h>
 #include <asm/atarikb.h>
 
-#include <video/fbcon.h>
-#include <video/fbcon-cfb8.h>
-#include <video/fbcon-cfb16.h>
-#include <video/fbcon-iplan2p2.h>
-#include <video/fbcon-iplan2p4.h>
-#include <video/fbcon-iplan2p8.h>
-#include <video/fbcon-mfb.h>
-
+#include "c2p.h"
+#include "atafb.h"
 
 #define SWITCH_ACIA 0x01                /* modes for switch on OverScan */
 #define SWITCH_SND6 0x40
@@ -87,22 +81,48 @@
 
 #define up(x, r) (((x) + (r) - 1) & ~((r)-1))
 
+        /*
+         * Interface to the world
+         */
+
+static int atafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info);
+static int atafb_set_par(struct fb_info *info);
+static int atafb_setcolreg(unsigned int regno, unsigned int red, unsigned int green,
+                           unsigned int blue, unsigned int transp,
+                           struct fb_info *info);
+static int atafb_blank(int blank, struct fb_info *info);
+static int atafb_pan_display(struct fb_var_screeninfo *var,
+                             struct fb_info *info);
+static void atafb_fillrect(struct fb_info *info,
+                           const struct fb_fillrect *rect);
+static void atafb_copyarea(struct fb_info *info,
+                           const struct fb_copyarea *region);
+static void atafb_imageblit(struct fb_info *info, const struct fb_image *image);
+static int atafb_ioctl(struct fb_info *info, unsigned int cmd,
+                       unsigned long arg);
+
 
-static int default_par=0;       /* default resolution (0=none) */
+static int default_par;         /* default resolution (0=none) */
 
-static unsigned long default_mem_req=0;
+static unsigned long default_mem_req;
 
-static int hwscroll=-1;
+static int hwscroll = -1;
 
 static int use_hwscroll = 1;
 
-static int sttt_xres=640,st_yres=400,tt_yres=480;
-static int sttt_xres_virtual=640,sttt_yres_virtual=400;
-static int ovsc_offset=0, ovsc_addlen=0;
+static int sttt_xres = 640, st_yres = 400, tt_yres = 480;
+static int sttt_xres_virtual = 640, sttt_yres_virtual = 400;
+static int ovsc_offset, ovsc_addlen;
+
+        /*
+         * Hardware parameters for current mode
+         */
 
 static struct atafb_par {
         void *screen_base;
         int yres_virtual;
+        u_long next_line;
+        u_long next_plane;
 #if defined ATAFB_TT || defined ATAFB_STE
         union {
                 struct {
@@ -138,7 +158,7 @@ static struct atafb_par {
 /* Don't calculate an own resolution, and thus don't change the one found when
  * booting (currently used for the Falcon to keep settings for internal video
  * hardware extensions (e.g. ScreenBlaster)  */
-static int DontCalcRes = 0; 
+static int DontCalcRes = 0;
 
 #ifdef ATAFB_FALCON
 #define HHT hw.falcon.hht
@@ -163,83 +183,84 @@ static int DontCalcRes = 0;
 #define VMO_PREMASK             0x0c
 #endif
 
-static struct fb_info fb_info;
+static struct fb_info fb_info = {
+        .fix = {
+                .id     = "Atari ",
+                .visual = FB_VISUAL_PSEUDOCOLOR,
+                .accel  = FB_ACCEL_NONE,
+        }
+};
 
 static void *screen_base;       /* base address of screen */
 static void *real_screen_base;  /* (only for Overscan) */
 
 static int screen_len;
 
-static int current_par_valid=0; 
+static int current_par_valid;
 
-static int mono_moni=0;
-
-static struct display disp;
+static int mono_moni;
 
 
 #ifdef ATAFB_EXT
-/* external video handling */
 
-static unsigned                 external_xres;
-static unsigned                 external_xres_virtual;
-static unsigned                 external_yres;
-/* not needed - atafb will never support panning/hardwarescroll with external
- * static unsigned              external_yres_virtual;  
-*/
+/* external video handling */
+static unsigned int external_xres;
+static unsigned int external_xres_virtual;
+static unsigned int external_yres;
 
-static unsigned                 external_depth;
-static int                              external_pmode;
-static void *external_addr = 0;
-static unsigned long    external_len;
-static unsigned long    external_vgaiobase = 0;
-static unsigned int             external_bitspercol = 6;
-
-/* 
-JOE <joe@amber.dinoco.de>: 
-added card type for external driver, is only needed for
-colormap handling.
-*/
+/*
+ * not needed - atafb will never support panning/hardwarescroll with external
+ * static unsigned int external_yres_virtual;
+ */
+static unsigned int external_depth;
+static int external_pmode;
+static void *external_addr;
+static unsigned long external_len;
+static unsigned long external_vgaiobase;
+static unsigned int external_bitspercol = 6;
 
+/*
+ * JOE <joe@amber.dinoco.de>:
+ * added card type for external driver, is only needed for
+ * colormap handling.
+ */
 enum cardtype { IS_VGA, IS_MV300 };
 static enum cardtype external_card_type = IS_VGA;
 
 /*
-The MV300 mixes the color registers. So we need an array of munged
-indices in order to access the correct reg.
-*/
-static int MV300_reg_1bit[2]={0,1};
-static int MV300_reg_4bit[16]={
-0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 };
-static int MV300_reg_8bit[256]={
-0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240, 
-8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248, 
-4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244, 
-12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252, 
-2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242, 
-10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250, 
-6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246, 
-14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254, 
-1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241, 
-9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249, 
-5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245, 
-13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253, 
-3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243, 
-11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251, 
-7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247, 
-15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255 }; 
+ * The MV300 mixes the color registers. So we need an array of munged
+ * indices in order to access the correct reg.
+ */
+static int MV300_reg_1bit[2] = {
+        0, 1
+};
+static int MV300_reg_4bit[16] = {
+        0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
+};
+static int MV300_reg_8bit[256] = {
+        0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240,
+        8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248,
+        4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244,
+        12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
+        2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
+        10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
+        6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246,
+        14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254,
+        1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241,
+        9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249,
+        5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245,
+        13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253,
+        3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243,
+        11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251,
+        7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247,
+        15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255
+};
 
 static int *MV300_reg = MV300_reg_8bit;
-
-/*
-And on the MV300 it's difficult to read out the hardware palette. So we
-just keep track of the set colors in our own array here, and use that!
-*/
-
-static struct { unsigned char red,green,blue,pad; } ext_color[256];
 #endif /* ATAFB_EXT */
 
 
-static int inverse=0;
+static int inverse;
 
 extern int fontheight_8x8;
 extern int fontwidth_8x8;
@@ -249,96 +270,154 @@ extern int fontheight_8x16;
 extern int fontwidth_8x16;
 extern unsigned char fontdata_8x16[];
 
+/*
+ * struct fb_ops {
+ *      * open/release and usage marking
+ *      struct module *owner;
+ *      int (*fb_open)(struct fb_info *info, int user);
+ *      int (*fb_release)(struct fb_info *info, int user);
+ *
+ *      * For framebuffers with strange non linear layouts or that do not
+ *      * work with normal memory mapped access
+ *      ssize_t (*fb_read)(struct file *file, char __user *buf, size_t count, loff_t *ppos);
+ *      ssize_t (*fb_write)(struct file *file, const char __user *buf, size_t count, loff_t *ppos);
+ *
+ *      * checks var and eventually tweaks it to something supported,
+ *      * DOES NOT MODIFY PAR *
+ *      int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);
+ *
+ *      * set the video mode according to info->var *
+ *      int (*fb_set_par)(struct fb_info *info);
+ *
+ *      * set color register *
+ *      int (*fb_setcolreg)(unsigned int regno, unsigned int red, unsigned int green,
+ *                          unsigned int blue, unsigned int transp, struct fb_info *info);
+ *
+ *      * set color registers in batch *
+ *      int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);
+ *
+ *      * blank display *
+ *      int (*fb_blank)(int blank, struct fb_info *info);
+ *
+ *      * pan display *
+ *      int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);
+ *
+ *      *** The meat of the drawing engine ***
+ *      * Draws a rectangle *
+ *      void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
+ *      * Copy data from area to another *
+ *      void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);
+ *      * Draws a image to the display *
+ *      void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);
+ *
+ *      * Draws cursor *
+ *      int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
+ *
+ *      * Rotates the display *
+ *      void (*fb_rotate)(struct fb_info *info, int angle);
+ *
+ *      * wait for blit idle, optional *
+ *      int (*fb_sync)(struct fb_info *info);
+ *
+ *      * perform fb specific ioctl (optional) *
+ *      int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
+ *                      unsigned long arg);
+ *
+ *      * Handle 32bit compat ioctl (optional) *
+ *      int (*fb_compat_ioctl)(struct fb_info *info, unsigned int cmd,
+ *                      unsigned long arg);
+ *
+ *      * perform fb specific mmap *
+ *      int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
+ *
+ *      * save current hardware state *
+ *      void (*fb_save_state)(struct fb_info *info);
+ *
+ *      * restore saved state *
+ *      void (*fb_restore_state)(struct fb_info *info);
+ * } ;
+ */
+
+
 /* ++roman: This structure abstracts from the underlying hardware (ST(e),
  * TT, or Falcon.
  *
- * int (*detect)( void )
+ * int (*detect)(void)
  *   This function should detect the current video mode settings and
  *   store them in atafb_predefined[0] for later reference by the
  *   user. Return the index+1 of an equivalent predefined mode or 0
  *   if there is no such.
- * 
- * int (*encode_fix)( struct fb_fix_screeninfo *fix,
- *                    struct atafb_par *par )
+ *
+ * int (*encode_fix)(struct fb_fix_screeninfo *fix,
+ *                   struct atafb_par *par)
  *   This function should fill in the 'fix' structure based on the
  *   values in the 'par' structure.
- *   
- * int (*decode_var)( struct fb_var_screeninfo *var,
- *                    struct atafb_par *par )
+ * !!! Obsolete, perhaps !!!
+ *
+ * int (*decode_var)(struct fb_var_screeninfo *var,
+ *                   struct atafb_par *par)
  *   Get the video params out of 'var'. If a value doesn't fit, round
  *   it up, if it's too big, return EINVAL.
- *   Round up in the following order: bits_per_pixel, xres, yres, 
- *   xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields, 
+ *   Round up in the following order: bits_per_pixel, xres, yres,
+ *   xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
  *   horizontal timing, vertical timing.
  *
- * int (*encode_var)( struct fb_var_screeninfo *var,
- *                    struct atafb_par *par );
+ * int (*encode_var)(struct fb_var_screeninfo *var,
+ *                   struct atafb_par *par);
  *   Fill the 'var' structure based on the values in 'par' and maybe
  *   other values read out of the hardware.
- *   
- * void (*get_par)( struct atafb_par *par )
+ *
+ * void (*get_par)(struct atafb_par *par)
  *   Fill the hardware's 'par' structure.
- *   
- * void (*set_par)( struct atafb_par *par )
+ *   !!! Used only by detect() !!!
+ *
+ * void (*set_par)(struct atafb_par *par)
  *   Set the hardware according to 'par'.
- *   
- * int (*getcolreg)( unsigned regno, unsigned *red,
- *                   unsigned *green, unsigned *blue,
- *                   unsigned *transp, struct fb_info *info )
- *   Read a single color register and split it into
- *   colors/transparent. Return != 0 for invalid regno.
  *
  * void (*set_screen_base)(void *s_base)
  *   Set the base address of the displayed frame buffer. Only called
  *   if yres_virtual > yres or xres_virtual > xres.
  *
- * int (*blank)( int blank_mode )
- *   Blank the screen if blank_mode!=0, else unblank. If blank==NULL then
+ * int (*blank)(int blank_mode)
+ *   Blank the screen if blank_mode != 0, else unblank. If blank == NULL then
  *   the caller blanks by setting the CLUT to all black. Return 0 if blanking
  *   succeeded, !=0 if un-/blanking failed due to e.g. a video mode which
  *   doesn't support it. Implements VESA suspend and powerdown modes on
  *   hardware that supports disabling hsync/vsync:
- *       blank_mode==2: suspend vsync, 3:suspend hsync, 4: powerdown.
+ *       blank_mode == 2: suspend vsync, 3:suspend hsync, 4: powerdown.
  */
 
 static struct fb_hwswitch {
-        int  (*detect)( void );
-        int  (*encode_fix)( struct fb_fix_screeninfo *fix,
-                                                struct atafb_par *par );
-        int  (*decode_var)( struct fb_var_screeninfo *var,
-                                                struct atafb_par *par );
-        int  (*encode_var)( struct fb_var_screeninfo *var,
-                                                struct atafb_par *par );
-        void (*get_par)( struct atafb_par *par );
-        void (*set_par)( struct atafb_par *par );
-        int  (*getcolreg)( unsigned regno, unsigned *red,
-                                           unsigned *green, unsigned *blue,
-                                           unsigned *transp, struct fb_info *info );
+        int (*detect)(void);
+        int (*encode_fix)(struct fb_fix_screeninfo *fix,
+                          struct atafb_par *par);
+        int (*decode_var)(struct fb_var_screeninfo *var,
+                          struct atafb_par *par);
+        int (*encode_var)(struct fb_var_screeninfo *var,
+                          struct atafb_par *par);
+        void (*get_par)(struct atafb_par *par);
+        void (*set_par)(struct atafb_par *par);
         void (*set_screen_base)(void *s_base);
-        int  (*blank)( int blank_mode );
-        int  (*pan_display)( struct fb_var_screeninfo *var,
-                                                 struct atafb_par *par);
+        int (*blank)(int blank_mode);
+        int (*pan_display)(struct fb_var_screeninfo *var,
+                           struct fb_info *info);
 } *fbhw;
 
-static char *autodetect_names[] = {"autodetect", NULL};
-static char *stlow_names[] = {"stlow", NULL};
-static char *stmid_names[] = {"stmid", "default5", NULL};
-static char *sthigh_names[] = {"sthigh", "default4", NULL};
-static char *ttlow_names[] = {"ttlow", NULL};
-static char *ttmid_names[]= {"ttmid", "default1", NULL};
-static char *tthigh_names[]= {"tthigh", "default2", NULL};
-static char *vga2_names[] = {"vga2", NULL};
-static char *vga4_names[] = {"vga4", NULL};
-static char *vga16_names[] = {"vga16", "default3", NULL};
-static char *vga256_names[] = {"vga256", NULL};
-static char *falh2_names[] = {"falh2", NULL};
-static char *falh16_names[] = {"falh16", NULL};
+static char *autodetect_names[] = { "autodetect", NULL };
+static char *stlow_names[] = { "stlow", NULL };
+static char *stmid_names[] = { "stmid", "default5", NULL };
+static char *sthigh_names[] = { "sthigh", "default4", NULL };
+static char *ttlow_names[] = { "ttlow", NULL };
+static char *ttmid_names[] = { "ttmid", "default1", NULL };
+static char *tthigh_names[] = { "tthigh", "default2", NULL };
+static char *vga2_names[] = { "vga2", NULL };
+static char *vga4_names[] = { "vga4", NULL };
+static char *vga16_names[] = { "vga16", "default3", NULL };
+static char *vga256_names[] = { "vga256", NULL };
+static char *falh2_names[] = { "falh2", NULL };
+static char *falh16_names[] = { "falh16", NULL };
 
 static char **fb_var_names[] = {
-        /* Writing the name arrays directly in this array (via "(char *[]){...}")
-         * crashes gcc 2.5.8 (sigsegv) if the inner array
-         * contains more than two items. I've also seen that all elements
-         * were identical to the last (my cross-gcc) :-(*/
         autodetect_names,
         stlow_names,
         stmid_names,
@@ -353,18 +432,17 @@ static char **fb_var_names[] = {
         falh2_names,
         falh16_names,
         NULL
-        /* ,NULL */ /* this causes a sigsegv on my gcc-2.5.8 */
 };
 
 static struct fb_var_screeninfo atafb_predefined[] = {
-        /*
-         * yres_virtual==0 means use hw-scrolling if possible, else yres
-         */
-        { /* autodetect */
-          0, 0, 0, 0, 0, 0, 0, 0,               /* xres-grayscale */
-          {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},   /* red green blue tran*/
+        /*
+         * yres_virtual == 0 means use hw-scrolling if possible, else yres
+         */
+        { /* autodetect */
+          0, 0, 0, 0, 0, 0, 0, 0,               /* xres-grayscale */
+          {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},   /* red green blue tran*/
           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
-        { /* st low */
+        { /* st low */
           320, 200, 320, 0, 0, 0, 4, 0,
           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
@@ -414,27 +492,100 @@ static struct fb_var_screeninfo atafb_predefined[] = {
           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 };
 
-static int num_atafb_predefined=ARRAY_SIZE(atafb_predefined);
+static int num_atafb_predefined = ARRAY_SIZE(atafb_predefined);
 
+static struct fb_videomode atafb_modedb[] __initdata = {
+        /*
+         *  Atari Video Modes
+         *
+         *  If you change these, make sure to update DEFMODE_* as well!
+         */
 
-static int
-get_video_mode(char *vname)
+        /*
+         *  ST/TT Video Modes
+         */
+
+        {
+                /* 320x200, 15 kHz, 60 Hz (ST low) */
+                "st-low", 60, 320, 200, 32000, 32, 16, 31, 14, 96, 4,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        }, {
+                /* 640x200, 15 kHz, 60 Hz (ST medium) */
+                "st-mid", 60, 640, 200, 32000, 32, 16, 31, 14, 96, 4,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        }, {
+                /* 640x400, 30.25 kHz, 63.5 Hz (ST high) */
+                "st-high", 63, 640, 400, 32000, 128, 0, 40, 14, 128, 4,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        }, {
+                /* 320x480, 15 kHz, 60 Hz (TT low) */
+                "tt-low", 60, 320, 480, 31041, 120, 100, 8, 16, 140, 30,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        }, {
+                /* 640x480, 29 kHz, 57 Hz (TT medium) */
+                "tt-mid", 60, 640, 480, 31041, 120, 100, 8, 16, 140, 30,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        }, {
+                /* 1280x960, 29 kHz, 60 Hz (TT high) */
+                "tt-high", 57, 640, 960, 31041, 120, 100, 8, 16, 140, 30,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        },
+
+        /*
+         *  VGA Video Modes
+         */
+
+        {
+                /* 640x480, 31 kHz, 60 Hz (VGA) */
+                "vga", 63.5, 640, 480, 32000, 18, 42, 31, 11, 96, 3,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        }, {
+                /* 640x400, 31 kHz, 70 Hz (VGA) */
+                "vga70", 70, 640, 400, 32000, 18, 42, 31, 11, 96, 3,
+                FB_SYNC_VERT_HIGH_ACT | FB_SYNC_COMP_HIGH_ACT, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        },
+
+        /*
+         *  Falcon HiRes Video Modes
+         */
+
+        {
+                /* 896x608, 31 kHz, 60 Hz (Falcon High) */
+                "falh", 60, 896, 608, 32000, 18, 42, 31, 1, 96,3,
+                0, FB_VMODE_NONINTERLACED | FB_VMODE_YWRAP
+        },
+};
+
+#define NUM_TOTAL_MODES  ARRAY_SIZE(atafb_modedb)
+
+static char *mode_option __initdata = NULL;
+
+ /* default modes */
+
+#define DEFMODE_TT      5               /* "tt-high" for TT */
+#define DEFMODE_F30     7               /* "vga70" for Falcon */
+#define DEFMODE_STE     2               /* "st-high" for ST/E */
+#define DEFMODE_EXT     6               /* "vga" for external */
+
+
+static int get_video_mode(char *vname)
 {
-    char ***name_list;
-    char **name;
-    int i;
-    name_list=fb_var_names;
-    for (i = 0 ; i < num_atafb_predefined ; i++) {
-        name=*(name_list++);
-        if (! name || ! *name)
-            break;
-        while (*name) {
-            if (! strcmp(vname, *name))
-                return i+1;
-            name++;
+        char ***name_list;
+        char **name;
+        int i;
+
+        name_list = fb_var_names;
+        for (i = 0; i < num_atafb_predefined; i++) {
+                name = *name_list++;
+                if (!name || !*name)
+                        break;
+                while (*name) {
+                        if (!strcmp(vname, *name))
+                                return i + 1;
+                        name++;
+                }
         }
-    }
-    return 0;
+        return 0;
 }
 
 
@@ -443,93 +594,84 @@ get_video_mode(char *vname)
 
 #ifdef ATAFB_TT
 
-static int tt_encode_fix( struct fb_fix_screeninfo *fix,
-                                                  struct atafb_par *par )
-
+static int tt_encode_fix(struct fb_fix_screeninfo *fix, struct atafb_par *par)
 {
         int mode;
 
-        strcpy(fix->id,"Atari Builtin");
+        strcpy(fix->id, "Atari Builtin");
         fix->smem_start = (unsigned long)real_screen_base;
         fix->smem_len = screen_len;
-        fix->type=FB_TYPE_INTERLEAVED_PLANES;
-        fix->type_aux=2;
-        fix->visual=FB_VISUAL_PSEUDOCOLOR;
+        fix->type = FB_TYPE_INTERLEAVED_PLANES;
+        fix->type_aux = 2;
+        fix->visual = FB_VISUAL_PSEUDOCOLOR;
         mode = par->hw.tt.mode & TT_SHIFTER_MODEMASK;
         if (mode == TT_SHIFTER_TTHIGH || mode == TT_SHIFTER_STHIGH) {
-                fix->type=FB_TYPE_PACKED_PIXELS;
-                fix->type_aux=0;
+                fix->type = FB_TYPE_PACKED_PIXELS;
+                fix->type_aux = 0;
                 if (mode == TT_SHIFTER_TTHIGH)
-                        fix->visual=FB_VISUAL_MONO01;
+                        fix->visual = FB_VISUAL_MONO01;
         }
-        fix->xpanstep=0;
-        fix->ypanstep=1;
-        fix->ywrapstep=0;
+        fix->xpanstep = 0;
+        fix->ypanstep = 1;
+        fix->ywrapstep = 0;
         fix->line_length = 0;
         fix->accel = FB_ACCEL_ATARIBLITT;
         return 0;
 }
 
-
-static int tt_decode_var( struct fb_var_screeninfo *var,
-                                                  struct atafb_par *par )
+static int tt_decode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
 {
-        int xres=var->xres;
-        int yres=var->yres;
-        int bpp=var->bits_per_pixel;
+        int xres = var->xres;
+        int yres = var->yres;
+        int bpp = var->bits_per_pixel;
         int linelen;
         int yres_virtual = var->yres_virtual;
 
         if (mono_moni) {
-                if (bpp > 1 || xres > sttt_xres*2 || yres >tt_yres*2)
+                if (bpp > 1 || xres > sttt_xres * 2 || yres > tt_yres * 2)
                         return -EINVAL;
-                par->hw.tt.mode=TT_SHIFTER_TTHIGH;
-                xres=sttt_xres*2;
-                yres=tt_yres*2;
-                bpp=1;
+                par->hw.tt.mode = TT_SHIFTER_TTHIGH;
+                xres = sttt_xres * 2;
+                yres = tt_yres * 2;
+                bpp = 1;
         } else {
                 if (bpp > 8 || xres > sttt_xres || yres > tt_yres)
                         return -EINVAL;
                 if (bpp > 4) {
-                        if (xres > sttt_xres/2 || yres > tt_yres)
+                        if (xres > sttt_xres / 2 || yres > tt_yres)
                                 return -EINVAL;
-                        par->hw.tt.mode=TT_SHIFTER_TTLOW;
-                        xres=sttt_xres/2;
-                        yres=tt_yres;
-                        bpp=8;
-                }
-                else if (bpp > 2) {
+                        par->hw.tt.mode = TT_SHIFTER_TTLOW;
+                        xres = sttt_xres / 2;
+                        yres = tt_yres;
+                        bpp = 8;
+                } else if (bpp > 2) {
                         if (xres > sttt_xres || yres > tt_yres)
                                 return -EINVAL;
-                        if (xres > sttt_xres/2 || yres > st_yres/2) {
-                                par->hw.tt.mode=TT_SHIFTER_TTMID;
-                                xres=sttt_xres;
-                                yres=tt_yres;
-                                bpp=4;
-                        }
-                        else {
-                                par->hw.tt.mode=TT_SHIFTER_STLOW;
-                                xres=sttt_xres/2;
-                                yres=st_yres/2;
-                                bpp=4;
+                        if (xres > sttt_xres / 2 || yres > st_yres / 2) {
+                                par->hw.tt.mode = TT_SHIFTER_TTMID;
+                                xres = sttt_xres;
+                                yres = tt_yres;
+                                bpp = 4;
+                        } else {
+                                par->hw.tt.mode = TT_SHIFTER_STLOW;
+                                xres = sttt_xres / 2;
+                                yres = st_yres / 2;
+                                bpp = 4;
                         }
-                }
-                else if (bpp > 1) {
-                        if (xres > sttt_xres || yres > st_yres/2)
+                } else if (bpp > 1) {
+                        if (xres > sttt_xres || yres > st_yres / 2)
                                 return -EINVAL;
-                        par->hw.tt.mode=TT_SHIFTER_STMID;
-                        xres=sttt_xres;
-                        yres=st_yres/2;
-                        bpp=2;
-                }
-                else if (var->xres > sttt_xres || var->yres > st_yres) {
+                        par->hw.tt.mode = TT_SHIFTER_STMID;
+                        xres = sttt_xres;
+                        yres = st_yres / 2;
+                        bpp = 2;
+                } else if (var->xres > sttt_xres || var->yres > st_yres) {
                         return -EINVAL;
-                }
-                else {
-                        par->hw.tt.mode=TT_SHIFTER_STHIGH;
-                        xres=sttt_xres;
-                        yres=st_yres;
-                        bpp=1;
+                } else {
+                        par->hw.tt.mode = TT_SHIFTER_STHIGH;
+                        xres = sttt_xres;
+                        yres = st_yres;
+                        bpp = 1;
                 }
         }
         if (yres_virtual <= 0)
@@ -537,10 +679,10 @@ static int tt_decode_var( struct fb_var_screeninfo *var,
         else if (yres_virtual < yres)
                 yres_virtual = yres;
         if (var->sync & FB_SYNC_EXT)
-                par->hw.tt.sync=0;
+                par->hw.tt.sync = 0;
         else
-                par->hw.tt.sync=1;
-        linelen=xres*bpp/8;
+                par->hw.tt.sync = 1;
+        linelen = xres * bpp / 8;
         if (yres_virtual * linelen > screen_len && screen_len)
                 return -EINVAL;
         if (yres * linelen > screen_len && screen_len)
@@ -552,154 +694,123 @@ static int tt_decode_var( struct fb_var_screeninfo *var,
         return 0;
 }
 
-static int tt_encode_var( struct fb_var_screeninfo *var,
-                                                  struct atafb_par *par )
+static int tt_encode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
 {
         int linelen;
         memset(var, 0, sizeof(struct fb_var_screeninfo));
-        var->red.offset=0;
-        var->red.length=4;
-        var->red.msb_right=0;
-        var->grayscale=0;
-
-        var->pixclock=31041;
-        var->left_margin=120;           /* these may be incorrect       */
-        var->right_margin=100;
-        var->upper_margin=8;
-        var->lower_margin=16;
-        var->hsync_len=140;
-        var->vsync_len=30;
-
-        var->height=-1;
-        var->width=-1;
+        var->red.offset = 0;
+        var->red.length = 4;
+        var->red.msb_right = 0;
+        var->grayscale = 0;
+
+        var->pixclock = 31041;
+        var->left_margin = 120;         /* these may be incorrect */
+        var->right_margin = 100;
+        var->upper_margin = 8;
+        var->lower_margin = 16;
+        var->hsync_len = 140;
+        var->vsync_len = 30;
+
+        var->height = -1;
+        var->width = -1;
 
         if (par->hw.tt.sync & 1)
-                var->sync=0;
+                var->sync = 0;
         else
-                var->sync=FB_SYNC_EXT;
+                var->sync = FB_SYNC_EXT;
 
         switch (par->hw.tt.mode & TT_SHIFTER_MODEMASK) {
         case TT_SHIFTER_STLOW:
-                var->xres=sttt_xres/2;
-                var->xres_virtual=sttt_xres_virtual/2;
-                var->yres=st_yres/2;
-                var->bits_per_pixel=4;
+                var->xres = sttt_xres / 2;
+                var->xres_virtual = sttt_xres_virtual / 2;
+                var->yres = st_yres / 2;
+                var->bits_per_pixel = 4;
                 break;
         case TT_SHIFTER_STMID:
-                var->xres=sttt_xres;
-                var->xres_virtual=sttt_xres_virtual;
-                var->yres=st_yres/2;
-                var->bits_per_pixel=2;
+                var->xres = sttt_xres;
+                var->xres_virtual = sttt_xres_virtual;
+                var->yres = st_yres / 2;
+                var->bits_per_pixel = 2;
                 break;
         case TT_SHIFTER_STHIGH:
-                var->xres=sttt_xres;
-                var->xres_virtual=sttt_xres_virtual;
-                var->yres=st_yres;
-                var->bits_per_pixel=1;
+                var->xres = sttt_xres;
+                var->xres_virtual = sttt_xres_virtual;
+                var->yres = st_yres;
+                var->bits_per_pixel = 1;
                 break;
         case TT_SHIFTER_TTLOW:
-                var->xres=sttt_xres/2;
-                var->xres_virtual=sttt_xres_virtual/2;
-                var->yres=tt_yres;
-                var->bits_per_pixel=8;
+                var->xres = sttt_xres / 2;
+                var->xres_virtual = sttt_xres_virtual / 2;
+                var->yres = tt_yres;
+                var->bits_per_pixel = 8;
                 break;
         case TT_SHIFTER_TTMID:
-                var->xres=sttt_xres;
-                var->xres_virtual=sttt_xres_virtual;
-                var->yres=tt_yres;
-                var->bits_per_pixel=4;
+                var->xres = sttt_xres;
+                var->xres_virtual = sttt_xres_virtual;
+                var->yres = tt_yres;
+                var->bits_per_pixel = 4;
                 break;
         case TT_SHIFTER_TTHIGH:
-                var->red.length=0;
-                var->xres=sttt_xres*2;
-                var->xres_virtual=sttt_xres_virtual*2;
-                var->yres=tt_yres*2;
-                var->bits_per_pixel=1;
+                var->red.length = 0;
+                var->xres = sttt_xres * 2;
+                var->xres_virtual = sttt_xres_virtual * 2;
+                var->yres = tt_yres * 2;
+                var->bits_per_pixel = 1;
                 break;
-        }               
-        var->blue=var->green=var->red;
-        var->transp.offset=0;
-        var->transp.length=0;
-        var->transp.msb_right=0;
-        linelen=var->xres_virtual * var->bits_per_pixel / 8;
-        if (! use_hwscroll)
-                var->yres_virtual=var->yres;
+        }
+        var->blue = var->green = var->red;
+        var->transp.offset = 0;
+        var->transp.length = 0;
+        var->transp.msb_right = 0;
+        linelen = var->xres_virtual * var->bits_per_pixel / 8;
+        if (!use_hwscroll)
+                var->yres_virtual = var->yres;
         else if (screen_len) {
                 if (par->yres_virtual)
                         var->yres_virtual = par->yres_virtual;
                 else
-                        /* yres_virtual==0 means use maximum */
+                        /* yres_virtual == 0 means use maximum */
                         var->yres_virtual = screen_len / linelen;
         } else {
                 if (hwscroll < 0)
                         var->yres_virtual = 2 * var->yres;
                 else
-                        var->yres_virtual=var->yres+hwscroll * 16;
+                        var->yres_virtual = var->yres + hwscroll * 16;
         }
-        var->xoffset=0;
+        var->xoffset = 0;
         if (screen_base)
-                var->yoffset=(par->screen_base - screen_base)/linelen;
+                var->yoffset = (par->screen_base - screen_base) / linelen;
         else
-                var->yoffset=0;
-        var->nonstd=0;
-        var->activate=0;
-        var->vmode=FB_VMODE_NONINTERLACED;
+                var->yoffset = 0;
+        var->nonstd = 0;
+        var->activate = 0;
+        var->vmode = FB_VMODE_NONINTERLACED;
         return 0;
 }
 
-
-static void tt_get_par( struct atafb_par *par )
+static void tt_get_par(struct atafb_par *par)
 {
         unsigned long addr;
-        par->hw.tt.mode=shifter_tt.tt_shiftmode;
-        par->hw.tt.sync=shifter.syncmode;
+        par->hw.tt.mode = shifter_tt.tt_shiftmode;
+        par->hw.tt.sync = shifter.syncmode;
         addr = ((shifter.bas_hi & 0xff) << 16) |
                ((shifter.bas_md & 0xff) << 8)  |
                ((shifter.bas_lo & 0xff));
         par->screen_base = phys_to_virt(addr);
 }
 
-static void tt_set_par( struct atafb_par *par )
+static void tt_set_par(struct atafb_par *par)
 {
-        shifter_tt.tt_shiftmode=par->hw.tt.mode;
-        shifter.syncmode=par->hw.tt.sync;
+        shifter_tt.tt_shiftmode = par->hw.tt.mode;
+        shifter.syncmode = par->hw.tt.sync;
         /* only set screen_base if really necessary */
         if (current_par.screen_base != par->screen_base)
                 fbhw->set_screen_base(par->screen_base);
 }
 
-
-static int tt_getcolreg(unsigned regno, unsigned *red,
-                        unsigned *green, unsigned *blue,
-                        unsigned *transp, struct fb_info *info)
-{
-        int t, col;
-
-        if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) == TT_SHIFTER_STHIGH)
-                regno += 254;
-        if (regno > 255)
-                return 1;
-        t = tt_palette[regno];
-        col = t & 15;
-        col |= col << 4;
-        col |= col << 8;
-        *blue = col;
-        col = (t >> 4) & 15;
-        col |= col << 4;
-        col |= col << 8;
-        *green = col;
-        col = (t >> 8) & 15;
-        col |= col << 4;
-        col |= col << 8;
-        *red = col;
-        *transp = 0;
-        return 0;
-}
-
-
-static int tt_setcolreg(unsigned regno, unsigned red,
-                        unsigned green, unsigned blue,
-                        unsigned transp, struct fb_info *info)
+static int tt_setcolreg(unsigned int regno, unsigned int red,
+                        unsigned int green, unsigned int blue,
+                        unsigned int transp, struct fb_info *info)
 {
         if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) == TT_SHIFTER_STHIGH)
                 regno += 254;
@@ -708,15 +819,14 @@ static int tt_setcolreg(unsigned regno, unsigned red,
         tt_palette[regno] = (((red >> 12) << 8) | ((green >> 12) << 4) |
                              (blue >> 12));
         if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) ==
-                TT_SHIFTER_STHIGH && regno == 254)
+            TT_SHIFTER_STHIGH && regno == 254)
                 tt_palette[0] = 0;
         return 0;
 }
 
-                                                  
-static int tt_detect( void )
-
-{       struct atafb_par par;
+static int tt_detect(void)
+{
+        struct atafb_par par;
 
         /* Determine the connected monitor: The DMA sound must be
          * disabled before reading the MFP GPIP, because the Sound
@@ -726,9 +836,9 @@ static int tt_detect( void )
          * announced that the Eagle is TT compatible, but only the PCM is
          * missing...
          */
-        if (ATARIHW_PRESENT(PCM_8BIT)) { 
+        if (ATARIHW_PRESENT(PCM_8BIT)) {
                 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
-                udelay(20);     /* wait a while for things to settle down */
+                udelay(20);             /* wait a while for things to settle down */
         }
         mono_moni = (mfp.par_dt_reg & 0x80) == 0;
 
@@ -755,19 +865,24 @@ static struct pixel_clock {
         unsigned long f;        /* f/[Hz] */
         unsigned long t;        /* t/[ps] (=1/f) */
         int right, hsync, left; /* standard timing in clock cycles, not pixel */
-                /* hsync initialized in falcon_detect() */
+        /* hsync initialized in falcon_detect() */
         int sync_mask;          /* or-mask for hw.falcon.sync to set this clock */
         int control_mask;       /* ditto, for hw.falcon.vid_control */
-}
-f25  = {25175000, 39721, 18, 0, 42, 0x0, VCO_CLOCK25},
-f32  = {32000000, 31250, 18, 0, 42, 0x0, 0},
-fext = {       0,     0, 18, 0, 42, 0x1, 0};
+} f25 = {
+        25175000, 39721, 18, 0, 42, 0x0, VCO_CLOCK25
+}, f32 = {
+        32000000, 31250, 18, 0, 42, 0x0, 0
+}, fext = {
+        0, 0, 18, 0, 42, 0x1, 0
+};
 
 /* VIDEL-prescale values [mon_type][pixel_length from VCO] */
-static int vdl_prescale[4][3] = {{4,2,1}, {4,2,1}, {4,2,2}, {4,2,1}};
+static int vdl_prescale[4][3] = {
+        { 4,2,1 }, { 4,2,1 }, { 4,2,2 }, { 4,2,1 }
+};
 
 /* Default hsync timing [mon_type] in picoseconds */
-static long h_syncs[4] = {3000000, 4875000, 4000000, 4875000};
+static long h_syncs[4] = { 3000000, 4875000, 4000000, 4875000 };
 
 #ifdef FBCON_HAS_CFB16
 static u16 fbcon_cfb16_cmap[16];
@@ -775,12 +890,12 @@ static u16 fbcon_cfb16_cmap[16];
 
 static inline int hxx_prescale(struct falcon_hw *hw)
 {
-        return hw->ste_mode ? 16 :
-                   vdl_prescale[mon_type][hw->vid_mode >> 2 & 0x3];
+        return hw->ste_mode ? 16
+                            : vdl_prescale[mon_type][hw->vid_mode >> 2 & 0x3];
 }
 
-static int falcon_encode_fix( struct fb_fix_screeninfo *fix,
-                                                          struct atafb_par *par )
+static int falcon_encode_fix(struct fb_fix_screeninfo *fix,
+                             struct atafb_par *par)
 {
         strcpy(fix->id, "Atari Builtin");
         fix->smem_start = (unsigned long)real_screen_base;
@@ -796,8 +911,7 @@ static int falcon_encode_fix( struct fb_fix_screeninfo *fix,
                 fix->type_aux = 0;
                 /* no smooth scrolling with longword aligned video mem */
                 fix->xpanstep = 32;
-        }
-        else if (par->hw.falcon.f_shift & 0x100) {
+        } else if (par->hw.falcon.f_shift & 0x100) {
                 fix->type = FB_TYPE_PACKED_PIXELS;
                 fix->type_aux = 0;
                 /* Is this ok or should it be DIRECTCOLOR? */
@@ -809,9 +923,8 @@ static int falcon_encode_fix( struct fb_fix_screeninfo *fix,
         return 0;
 }
 
-
-static int falcon_decode_var( struct fb_var_screeninfo *var,
-                                                          struct atafb_par *par )
+static int falcon_decode_var(struct fb_var_screeninfo *var,
+                             struct atafb_par *par)
 {
         int bpp = var->bits_per_pixel;
         int xres = var->xres;
@@ -823,17 +936,19 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         int linelen;
         int interlace = 0, doubleline = 0;
         struct pixel_clock *pclock;
-        int plen; /* width of pixel in clock cycles */
+        int plen;                       /* width of pixel in clock cycles */
         int xstretch;
         int prescale;
         int longoffset = 0;
         int hfreq, vfreq;
+        int hdb_off, hde_off, base_off;
+        int gstart, gend1, gend2, align;
 
 /*
         Get the video params out of 'var'. If a value doesn't fit, round
         it up, if it's too big, return EINVAL.
-        Round up in the following order: bits_per_pixel, xres, yres, 
-        xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields, 
+        Round up in the following order: bits_per_pixel, xres, yres,
+        xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
         horizontal timing, vertical timing.
 
         There is a maximum of screen resolution determined by pixelclock
@@ -843,11 +958,11 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         Frequency range for multisync monitors is given via command line.
         For TV and SM124 both frequencies are fixed.
 
-        X % 16 == 0 to fit 8x?? font (except 1 bitplane modes must use X%32==0)
+        X % 16 == 0 to fit 8x?? font (except 1 bitplane modes must use X%32 == 0)
         Y % 16 == 0 to fit 8x16 font
         Y % 8 == 0 if Y<400
 
-        Currently interlace and doubleline mode in var are ignored. 
+        Currently interlace and doubleline mode in var are ignored.
         On SM124 and TV only the standard resolutions can be used.
 */
 
@@ -855,43 +970,38 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         if (!xres || !yres || !bpp)
                 return -EINVAL;
 
-        if (mon_type == F_MON_SM && bpp != 1) {
+        if (mon_type == F_MON_SM && bpp != 1)
                 return -EINVAL;
-        }
-        else if (bpp <= 1) {
+
+        if (bpp <= 1) {
                 bpp = 1;
                 par->hw.falcon.f_shift = 0x400;
                 par->hw.falcon.st_shift = 0x200;
-        }
-        else if (bpp <= 2) {
+        } else if (bpp <= 2) {
                 bpp = 2;
                 par->hw.falcon.f_shift = 0x000;
                 par->hw.falcon.st_shift = 0x100;
-        }
-        else if (bpp <= 4) {
+        } else if (bpp <= 4) {
                 bpp = 4;
                 par->hw.falcon.f_shift = 0x000;
                 par->hw.falcon.st_shift = 0x000;
-        }
-        else if (bpp <= 8) {
+        } else if (bpp <= 8) {
                 bpp = 8;
                 par->hw.falcon.f_shift = 0x010;
-        }
-        else if (bpp <= 16) {
-                bpp = 16; /* packed pixel mode */
-                par->hw.falcon.f_shift = 0x100; /* hicolor, no overlay */
-        }
-        else
+        } else if (bpp <= 16) {
+                bpp = 16;               /* packed pixel mode */
+                par->hw.falcon.f_shift = 0x100; /* hicolor, no overlay */
+        } else
                 return -EINVAL;
         par->hw.falcon.bpp = bpp;
 
         if (mon_type == F_MON_SM || DontCalcRes) {
                 /* Skip all calculations. VGA/TV/SC1224 only supported. */
                 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
-                
+
                 if (bpp > myvar->bits_per_pixel ||
-                        var->xres > myvar->xres ||
-                        var->yres > myvar->yres)
+                    var->xres > myvar->xres ||
+                    var->yres > myvar->yres)
                         return -EINVAL;
                 fbhw->get_par(par);     /* Current par will be new par */
                 goto set_screen_base;   /* Don't forget this */
@@ -910,8 +1020,8 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                 yres = 400;
 
         /* 2 planes must use STE compatibility mode */
-        par->hw.falcon.ste_mode = bpp==2;
-        par->hw.falcon.mono = bpp==1;
+        par->hw.falcon.ste_mode = bpp == 2;
+        par->hw.falcon.mono = bpp == 1;
 
         /* Total and visible scanline length must be a multiple of one longword,
          * this and the console fontwidth yields the alignment for xres and
@@ -967,8 +1077,7 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                 left_margin = hsync_len = 128 / plen;
                 right_margin = 0;
                 /* TODO set all margins */
-        }
-        else
+        } else
 #endif
         if (mon_type == F_MON_SC || mon_type == F_MON_TV) {
                 plen = 2 * xstretch;
@@ -1002,26 +1111,24 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                                 vsync_len *= 2;
                         }
                 }
-        }
-        else
-        {       /* F_MON_VGA */
+        } else {                        /* F_MON_VGA */
                 if (bpp == 16)
-                        xstretch = 2; /* Double pixel width only for hicolor */
+                        xstretch = 2;   /* Double pixel width only for hicolor */
                 /* Default values are used for vert./hor. timing if no pixelclock given. */
                 if (var->pixclock == 0) {
                         int linesize;
 
                         /* Choose master pixelclock depending on hor. timing */
                         plen = 1 * xstretch;
-                        if ((plen * xres + f25.right+f25.hsync+f25.left) *
+                        if ((plen * xres + f25.right + f25.hsync + f25.left) *
                             fb_info.monspecs.hfmin < f25.f)
                                 pclock = &f25;
-                        else if ((plen * xres + f32.right+f32.hsync+f32.left) * 
-                            fb_info.monspecs.hfmin < f32.f)
+                        else if ((plen * xres + f32.right + f32.hsync +
+                                  f32.left) * fb_info.monspecs.hfmin < f32.f)
                                 pclock = &f32;
-                        else if ((plen * xres + fext.right+fext.hsync+fext.left) * 
-                            fb_info.monspecs.hfmin < fext.f
-                                 && fext.f)
+                        else if ((plen * xres + fext.right + fext.hsync +
+                                  fext.left) * fb_info.monspecs.hfmin < fext.f &&
+                                 fext.f)
                                 pclock = &fext;
                         else
                                 return -EINVAL;
@@ -1033,22 +1140,24 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                         upper_margin = 31;
                         lower_margin = 11;
                         vsync_len = 3;
-                }
-                else {
+                } else {
                         /* Choose largest pixelclock <= wanted clock */
                         int i;
                         unsigned long pcl = ULONG_MAX;
                         pclock = 0;
-                        for (i=1; i <= 4; i *= 2) {
-                                if (f25.t*i >= var->pixclock && f25.t*i < pcl) {
+                        for (i = 1; i <= 4; i *= 2) {
+                                if (f25.t * i >= var->pixclock &&
+                                    f25.t * i < pcl) {
                                         pcl = f25.t * i;
                                         pclock = &f25;
                                 }
-                                if (f32.t*i >= var->pixclock && f32.t*i < pcl) {
+                                if (f32.t * i >= var->pixclock &&
+                                    f32.t * i < pcl) {
                                         pcl = f32.t * i;
                                         pclock = &f32;
                                 }
-                                if (fext.t && fext.t*i >= var->pixclock && fext.t*i < pcl) {
+                                if (fext.t && fext.t * i >= var->pixclock &&
+                                    fext.t * i < pcl) {
                                         pcl = fext.t * i;
                                         pclock = &fext;
                                 }
@@ -1070,8 +1179,7 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                                 upper_margin = (upper_margin + 1) / 2;
                                 lower_margin = (lower_margin + 1) / 2;
                                 vsync_len = (vsync_len + 1) / 2;
-                        }
-                        else if (var->vmode & FB_VMODE_DOUBLE) {
+                        } else if (var->vmode & FB_VMODE_DOUBLE) {
                                 /* External unit is [double lines per frame] */
                                 upper_margin *= 2;
                                 lower_margin *= 2;
@@ -1079,7 +1187,7 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                         }
                 }
                 if (pclock == &fext)
-                        longoffset = 1; /* VIDEL doesn't synchronize on short offset */
+                        longoffset = 1; /* VIDEL doesn't synchronize on short offset */
         }
         /* Is video bus bandwidth (32MB/s) too low for this resolution? */
         /* this is definitely wrong if bus clock != 32MHz */
@@ -1098,7 +1206,7 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
          * between interlace and non-interlace without messing around
          * with these.
          */
-  again:
+again:
         /* Set base_offset 128 and video bus width */
         par->hw.falcon.vid_control = mon_type | f030_bus_width;
         if (!longoffset)
@@ -1112,37 +1220,34 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         /* External or internal clock */
         par->hw.falcon.sync = pclock->sync_mask | 0x2;
         /* Pixellength and prescale */
-        par->hw.falcon.vid_mode = (2/plen) << 2;
+        par->hw.falcon.vid_mode = (2 / plen) << 2;
         if (doubleline)
                 par->hw.falcon.vid_mode |= VMO_DOUBLE;
         if (interlace)
                 par->hw.falcon.vid_mode |= VMO_INTER;
 
         /*********************
-        Horizontal timing: unit = [master clock cycles]
-        unit of hxx-registers: [master clock cycles * prescale]
-        Hxx-registers are 9 bit wide
-
-        1 line = ((hht + 2) * 2 * prescale) clock cycles
-
-        graphic output = hdb & 0x200 ?
-               ((hht+2)*2 - hdb + hde) * prescale - hdboff + hdeoff:
-               ( hht + 2  - hdb + hde) * prescale - hdboff + hdeoff
-        (this must be a multiple of plen*128/bpp, on VGA pixels
-         to the right may be cut off with a bigger right margin)
-
-        start of graphics relative to start of 1st halfline = hdb & 0x200 ?
-               (hdb - hht - 2) * prescale + hdboff :
-               hdb * prescale + hdboff
-
-        end of graphics relative to start of 1st halfline =
-               (hde + hht + 2) * prescale + hdeoff
-        *********************/
+         * Horizontal timing: unit = [master clock cycles]
+         * unit of hxx-registers: [master clock cycles * prescale]
+         * Hxx-registers are 9 bit wide
+         *
+         * 1 line = ((hht + 2) * 2 * prescale) clock cycles
+         *
+         * graphic output = hdb & 0x200 ?
+         *        ((hht + 2) * 2 - hdb + hde) * prescale - hdboff + hdeoff:
+         *        (hht + 2  - hdb + hde) * prescale - hdboff + hdeoff
+         * (this must be a multiple of plen*128/bpp, on VGA pixels
+         *  to the right may be cut off with a bigger right margin)
+         *
+         * start of graphics relative to start of 1st halfline = hdb & 0x200 ?
+         *        (hdb - hht - 2) * prescale + hdboff :
+         *        hdb * prescale + hdboff
+         *
+         * end of graphics relative to start of 1st halfline =
+         *        (hde + hht + 2) * prescale + hdeoff
+         *********************/
         /* Calculate VIDEL registers */
-        {
-        int hdb_off, hde_off, base_off;
-        int gstart, gend1, gend2, align;
-
+{
         prescale = hxx_prescale(&par->hw.falcon);
         base_off = par->hw.falcon.vid_control & VCO_SHORTOFFS ? 64 : 128;
 
@@ -1154,8 +1259,7 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                 align = 1;
                 hde_off = 0;
                 hdb_off = (base_off + 16 * plen) + prescale;
-        }
-        else {
+        } else {
                 align = 128 / bpp;
                 hde_off = ((128 / bpp + 2) * plen);
                 if (par->hw.falcon.ste_mode)
@@ -1164,23 +1268,24 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
                         hdb_off = (base_off + (128 / bpp + 18) * plen) + prescale;
         }
 
-        gstart = (prescale/2 + plen * left_margin) / prescale;
+        gstart = (prescale / 2 + plen * left_margin) / prescale;
         /* gend1 is for hde (gend-gstart multiple of align), shifter's xres */
-        gend1 = gstart + ((xres + align-1) / align)*align * plen / prescale;
+        gend1 = gstart + ((xres + align - 1) / align) * align * plen / prescale;
         /* gend2 is for hbb, visible xres (rest to gend1 is cut off by hblank) */
         gend2 = gstart + xres * plen / prescale;
         par->HHT = plen * (left_margin + xres + right_margin) /
                            (2 * prescale) - 2;
 /*      par->HHT = (gend2 + plen * right_margin / prescale) / 2 - 2;*/
 
-        par->HDB = gstart - hdb_off/prescale;
+        par->HDB = gstart - hdb_off / prescale;
         par->HBE = gstart;
-        if (par->HDB < 0) par->HDB += par->HHT + 2 + 0x200;
-        par->HDE = gend1 - par->HHT - 2 - hde_off/prescale;
+        if (par->HDB < 0)
+                par->HDB += par->HHT + 2 + 0x200;
+        par->HDE = gend1 - par->HHT - 2 - hde_off / prescale;
         par->HBB = gend2 - par->HHT - 2;
 #if 0
         /* One more Videl constraint: data fetch of two lines must not overlap */
-        if ((par->HDB & 0x200)  &&  (par->HDB & ~0x200) - par->HDE <= 5) {
+        if ((par->HDB & 0x200) && (par->HDB & ~0x200) - par->HDE <= 5) {
                 /* if this happens increase margins, decrease hfreq. */
         }
 #endif
@@ -1189,11 +1294,11 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         par->HSS = par->HHT + 2 - plen * hsync_len / prescale;
         if (par->HSS < par->HBB)
                 par->HSS = par->HBB;
-        }
+}
 
         /*  check hor. frequency */
-        hfreq = pclock->f / ((par->HHT+2)*prescale*2);
-        if (hfreq > fb_info.monspecs.hfmax && mon_type!=F_MON_VGA) {
+        hfreq = pclock->f / ((par->HHT + 2) * prescale * 2);
+        if (hfreq > fb_info.monspecs.hfmax && mon_type != F_MON_VGA) {
                 /* ++guenther:   ^^^^^^^^^^^^^^^^^^^ can't remember why I did this */
                 /* Too high -> enlarge margin */
                 left_margin += 1;
@@ -1213,12 +1318,14 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         par->VBE = (upper_margin * 2 + 1); /* must begin on odd halfline */
         par->VDB = par->VBE;
         par->VDE = yres;
-        if (!interlace) par->VDE <<= 1;
-        if (doubleline) par->VDE <<= 1;  /* VDE now half lines per (half-)frame */
+        if (!interlace)
+                par->VDE <<= 1;
+        if (doubleline)
+                par->VDE <<= 1;         /* VDE now half lines per (half-)frame */
         par->VDE += par->VDB;
         par->VBB = par->VDE;
         par->VFT = par->VBB + (lower_margin * 2 - 1) - 1;
-        par->VSS = par->VFT+1 - (vsync_len * 2 - 1);
+        par->VSS = par->VFT + 1 - (vsync_len * 2 - 1);
         /* vbb,vss,vft must be even in interlace mode */
         if (interlace) {
                 par->VBB++;
@@ -1229,55 +1336,53 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         /* V-frequency check, hope I didn't create any loop here. */
         /* Interlace and doubleline are mutually exclusive. */
         vfreq = (hfreq * 2) / (par->VFT + 1);
-        if      (vfreq > fb_info.monspecs.vfmax && !doubleline && !interlace) {
+        if (vfreq > fb_info.monspecs.vfmax && !doubleline && !interlace) {
                 /* Too high -> try again with doubleline */
                 doubleline = 1;
                 goto again;
-        }
-        else if (vfreq < fb_info.monspecs.vfmin && !interlace && !doubleline) {
+        } else if (vfreq < fb_info.monspecs.vfmin && !interlace && !doubleline) {
                 /* Too low -> try again with interlace */
                 interlace = 1;
                 goto again;
-        }
-        else if (vfreq < fb_info.monspecs.vfmin && doubleline) {
+        } else if (vfreq < fb_info.monspecs.vfmin && doubleline) {
                 /* Doubleline too low -> clear doubleline and enlarge margins */
                 int lines;
                 doubleline = 0;
-                for (lines=0;
-                     (hfreq*2)/(par->VFT+1+4*lines-2*yres)>fb_info.monspecs.vfmax;
+                for (lines = 0;
+                     (hfreq * 2) / (par->VFT + 1 + 4 * lines - 2 * yres) >
+                     fb_info.monspecs.vfmax;
                      lines++)
                         ;
                 upper_margin += lines;
                 lower_margin += lines;
                 goto again;
-        }
-        else if (vfreq > fb_info.monspecs.vfmax && doubleline) {
+        } else if (vfreq > fb_info.monspecs.vfmax && doubleline) {
                 /* Doubleline too high -> enlarge margins */
                 int lines;
-                for (lines=0;
-                     (hfreq*2)/(par->VFT+1+4*lines)>fb_info.monspecs.vfmax;
-                     lines+=2)
+                for (lines = 0;
+                     (hfreq * 2) / (par->VFT + 1 + 4 * lines) >
+                     fb_info.monspecs.vfmax;
+                     lines += 2)
                         ;
                 upper_margin += lines;
                 lower_margin += lines;
                 goto again;
-        }
-        else if (vfreq > fb_info.monspecs.vfmax && interlace) {
+        } else if (vfreq > fb_info.monspecs.vfmax && interlace) {
                 /* Interlace, too high -> enlarge margins */
                 int lines;
-                for (lines=0;
-                     (hfreq*2)/(par->VFT+1+4*lines)>fb_info.monspecs.vfmax;
+                for (lines = 0;
+                     (hfreq * 2) / (par->VFT + 1 + 4 * lines) >
+                     fb_info.monspecs.vfmax;
                      lines++)
                         ;
                 upper_margin += lines;
                 lower_margin += lines;
                 goto again;
-        }
-        else if (vfreq < fb_info.monspecs.vfmin ||
-                 vfreq > fb_info.monspecs.vfmax)
+        } else if (vfreq < fb_info.monspecs.vfmin ||
+                   vfreq > fb_info.monspecs.vfmax)
                 return -EINVAL;
 
-  set_screen_base:
+set_screen_base:
         linelen = xres_virtual * bpp / 8;
         if (yres_virtual * linelen > screen_len && screen_len)
                 return -EINVAL;
@@ -1289,11 +1394,20 @@ static int falcon_decode_var( struct fb_var_screeninfo *var,
         par->screen_base = screen_base + var->yoffset * linelen;
         par->hw.falcon.xoffset = 0;
 
+        // FIXME!!! sort of works, no crash
+        //par->next_line = linelen;
+        //par->next_plane = yres_virtual * linelen;
+        par->next_line = linelen;
+        par->next_plane = 2;
+        // crashes
+        //par->next_plane = linelen;
+        //par->next_line  = yres_virtual * linelen;
+
         return 0;
 }
 
-static int falcon_encode_var( struct fb_var_screeninfo *var,
-                                                          struct atafb_par *par )
+static int falcon_encode_var(struct fb_var_screeninfo *var,
+                             struct atafb_par *par)
 {
 /* !!! only for VGA !!! */
         int linelen;
@@ -1306,10 +1420,10 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
         var->pixclock = hw->sync & 0x1 ? fext.t :
                         hw->vid_control & VCO_CLOCK25 ? f25.t : f32.t;
 
-        var->height=-1;
-        var->width=-1;
+        var->height = -1;
+        var->width = -1;
 
-        var->sync=0;
+        var->sync = 0;
         if (hw->vid_control & VCO_HSYPOS)
                 var->sync |= FB_SYNC_HOR_HIGH_ACT;
         if (hw->vid_control & VCO_VSYPOS)
@@ -1320,7 +1434,7 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
                 var->vmode |= FB_VMODE_INTERLACED;
         if (hw->vid_mode & VMO_DOUBLE)
                 var->vmode |= FB_VMODE_DOUBLE;
-        
+
         /* visible y resolution:
          * Graphics display starts at line VDB and ends at line
          * VDE. If interlace mode off unit of VC-registers is
@@ -1332,14 +1446,15 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
         if (var->vmode & FB_VMODE_DOUBLE)
                 var->yres >>= 1;
 
-        /* to get bpp, we must examine f_shift and st_shift.
+        /*
+         * to get bpp, we must examine f_shift and st_shift.
          * f_shift is valid if any of bits no. 10, 8 or 4
          * is set. Priority in f_shift is: 10 ">" 8 ">" 4, i.e.
          * if bit 10 set then bit 8 and bit 4 don't care...
          * If all these bits are 0 get display depth from st_shift
          * (as for ST and STE)
          */
-        if (hw->f_shift & 0x400)                /* 2 colors */
+        if (hw->f_shift & 0x400)        /* 2 colors */
                 var->bits_per_pixel = 1;
         else if (hw->f_shift & 0x100)   /* hicolor */
                 var->bits_per_pixel = 16;
@@ -1349,7 +1464,7 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
                 var->bits_per_pixel = 4;
         else if (hw->st_shift == 0x100)
                 var->bits_per_pixel = 2;
-        else /* if (hw->st_shift == 0x200) */
+        else                            /* if (hw->st_shift == 0x200) */
                 var->bits_per_pixel = 1;
 
         var->xres = hw->line_width * 16 / var->bits_per_pixel;
@@ -1358,42 +1473,42 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
                 var->xres_virtual += 16;
 
         if (var->bits_per_pixel == 16) {
-                var->red.offset=11;
-                var->red.length=5;
-                var->red.msb_right=0;
-                var->green.offset=5;
-                var->green.length=6;
-                var->green.msb_right=0;
-                var->blue.offset=0;
-                var->blue.length=5;
-                var->blue.msb_right=0;
-        }
-        else {
-                var->red.offset=0;
+                var->red.offset = 11;
+                var->red.length = 5;
+                var->red.msb_right = 0;
+                var->green.offset = 5;
+                var->green.length = 6;
+                var->green.msb_right = 0;
+                var->blue.offset = 0;
+                var->blue.length = 5;
+                var->blue.msb_right = 0;
+        } else {
+                var->red.offset = 0;
                 var->red.length = hw->ste_mode ? 4 : 6;
-                var->red.msb_right=0;
-                var->grayscale=0;
-                var->blue=var->green=var->red;
+                if (var->red.length > var->bits_per_pixel)
+                        var->red.length = var->bits_per_pixel;
+                var->red.msb_right = 0;
+                var->grayscale = 0;
+                var->blue = var->green = var->red;
         }
-        var->transp.offset=0;
-        var->transp.length=0;
-        var->transp.msb_right=0;
+        var->transp.offset = 0;
+        var->transp.length = 0;
+        var->transp.msb_right = 0;
 
         linelen = var->xres_virtual * var->bits_per_pixel / 8;
         if (screen_len) {
                 if (par->yres_virtual)
                         var->yres_virtual = par->yres_virtual;
                 else
-                        /* yres_virtual==0 means use maximum */
+                        /* yres_virtual == 0 means use maximum */
                         var->yres_virtual = screen_len / linelen;
-        }
-        else {
+        } else {
                 if (hwscroll < 0)
                         var->yres_virtual = 2 * var->yres;
                 else
-                        var->yres_virtual=var->yres+hwscroll * 16;
+                        var->yres_virtual = var->yres + hwscroll * 16;
         }
-        var->xoffset=0; /* TODO change this */
+        var->xoffset = 0;               /* TODO change this */
 
         /* hdX-offsets */
         prescale = hxx_prescale(hw);
@@ -1402,8 +1517,7 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
         if (hw->f_shift & 0x100) {
                 hde_off = 0;
                 hdb_off = (base_off + 16 * plen) + prescale;
-        }
-        else {
+        } else {
                 hde_off = ((128 / var->bits_per_pixel + 2) * plen);
                 if (hw->ste_mode)
                         hdb_off = (64 + base_off + (128 / var->bits_per_pixel + 2) * plen)
@@ -1415,8 +1529,8 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
 
         /* Right margin includes hsync */
         var->left_margin = hdb_off + prescale * ((hw->hdb & 0x1ff) -
-                                           (hw->hdb & 0x200 ? 2+hw->hht : 0));
-        if (hw->ste_mode || mon_type!=F_MON_VGA)
+                                           (hw->hdb & 0x200 ? 2 + hw->hht : 0));
+        if (hw->ste_mode || mon_type != F_MON_VGA)
                 var->right_margin = prescale * (hw->hht + 2 - hw->hde) - hde_off;
         else
                 /* can't use this in ste_mode, because hbb is +1 off */
@@ -1424,15 +1538,14 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
         var->hsync_len = prescale * (hw->hht + 2 - hw->hss);
 
         /* Lower margin includes vsync */
-        var->upper_margin = hw->vdb / 2 ;  /* round down to full lines */
-        var->lower_margin = (hw->vft+1 - hw->vde + 1) / 2; /* round up */
-        var->vsync_len    = (hw->vft+1 - hw->vss + 1) / 2; /* round up */
+        var->upper_margin = hw->vdb / 2;        /* round down to full lines */
+        var->lower_margin = (hw->vft + 1 - hw->vde + 1) / 2;    /* round up */
+        var->vsync_len = (hw->vft + 1 - hw->vss + 1) / 2;       /* round up */
         if (var->vmode & FB_VMODE_INTERLACED) {
                 var->upper_margin *= 2;
                 var->lower_margin *= 2;
                 var->vsync_len *= 2;
-        }
-        else if (var->vmode & FB_VMODE_DOUBLE) {
+        } else if (var->vmode & FB_VMODE_DOUBLE) {
                 var->upper_margin = (var->upper_margin + 1) / 2;
                 var->lower_margin = (var->lower_margin + 1) / 2;
                 var->vsync_len = (var->vsync_len + 1) / 2;
@@ -1447,20 +1560,19 @@ static int falcon_encode_var( struct fb_var_screeninfo *var,
         var->lower_margin -= var->vsync_len;
 
         if (screen_base)
-                var->yoffset=(par->screen_base - screen_base)/linelen;
+                var->yoffset = (par->screen_base - screen_base) / linelen;
         else
-                var->yoffset=0;
-        var->nonstd=0;  /* what is this for? */
-        var->activate=0;
+                var->yoffset = 0;
+        var->nonstd = 0;                /* what is this for? */
+        var->activate = 0;
         return 0;
 }
 
-
-static int f_change_mode = 0;
+static int f_change_mode;
 static struct falcon_hw f_new_mode;
-static int f_pan_display = 0;
+static int f_pan_display;
 
-static void falcon_get_par( struct atafb_par *par )
+static void falcon_get_par(struct atafb_par *par)
 {
         unsigned long addr;
         struct falcon_hw *hw = &par->hw.falcon;
@@ -1492,12 +1604,12 @@ static void falcon_get_par( struct atafb_par *par )
         par->screen_base = phys_to_virt(addr);
 
         /* derived parameters */
-        hw->ste_mode = (hw->f_shift & 0x510)==0 && hw->st_shift==0x100;
+        hw->ste_mode = (hw->f_shift & 0x510) == 0 && hw->st_shift == 0x100;
         hw->mono = (hw->f_shift & 0x400) ||
-                   ((hw->f_shift & 0x510)==0 && hw->st_shift==0x200);
+                   ((hw->f_shift & 0x510) == 0 && hw->st_shift == 0x200);
 }
 
-static void falcon_set_par( struct atafb_par *par )
+static void falcon_set_par(struct atafb_par *par)
 {
         f_change_mode = 0;
 
@@ -1519,8 +1631,7 @@ static void falcon_set_par( struct atafb_par *par )
         f_change_mode = 1;
 }
 
-
-static irqreturn_t falcon_vbl_switcher( int irq, void *dummy )
+static irqreturn_t falcon_vbl_switcher(int irq, void *dummy)
 {
         struct falcon_hw *hw = &f_new_mode;
 
@@ -1529,11 +1640,10 @@ static irqreturn_t falcon_vbl_switcher( int irq, void *dummy )
 
                 if (hw->sync & 0x1) {
                         /* Enable external pixelclock. This code only for ScreenWonder */
-                        *(volatile unsigned short*)0xffff9202 = 0xffbf;
-                }
-                else {
+                        *(volatile unsigned short *)0xffff9202 = 0xffbf;
+                } else {
                         /* Turn off external clocks. Read sets all output bits to 1. */
-                        *(volatile unsigned short*)0xffff9202;
+                        *(volatile unsigned short *)0xffff9202;
                 }
                 shifter.syncmode = hw->sync;
 
@@ -1550,15 +1660,14 @@ static irqreturn_t falcon_vbl_switcher( int irq, void *dummy )
                 videl.vde = hw->vde;
                 videl.vss = hw->vss;
 
-                videl.f_shift = 0; /* write enables Falcon palette, 0: 4 planes */
+                videl.f_shift = 0;      /* write enables Falcon palette, 0: 4 planes */
                 if (hw->ste_mode) {
-                        videl.st_shift = hw->st_shift; /* write enables STE palette */
-                }
-                else {
+                        videl.st_shift = hw->st_shift;  /* write enables STE palette */
+                } else {
                         /* IMPORTANT:
-                         * set st_shift 0, so we can tell the screen-depth if f_shift==0.
+                         * set st_shift 0, so we can tell the screen-depth if f_shift == 0.
                          * Writing 0 to f_shift enables 4 plane Falcon mode but
-                         * doesn't set st_shift. st_shift!=0 (!=4planes) is impossible
+                         * doesn't set st_shift. st_shift != 0 (!= 4planes) is impossible
                          * with Falcon palette.
                          */
                         videl.st_shift = 0;
@@ -1580,12 +1689,13 @@ static irqreturn_t falcon_vbl_switcher( int irq, void *dummy )
         return IRQ_HANDLED;
 }
 
-
-static int falcon_pan_display( struct fb_var_screeninfo *var,
-                                                           struct atafb_par *par )
+static int falcon_pan_display(struct fb_var_screeninfo *var,
+                              struct fb_info *info)
 {
+        struct atafb_par *par = (struct atafb_par *)info->par;
+
         int xoffset;
-        int bpp = fb_display[fb_info.currcon].var.bits_per_pixel;
+        int bpp = info->var.bits_per_pixel;
 
         if (bpp == 1)
                 var->xoffset = up(var->xoffset, 32);
@@ -1596,45 +1706,24 @@ static int falcon_pan_display( struct fb_var_screeninfo *var,
                 var->xoffset = up(var->xoffset, 2);
         }
         par->hw.falcon.line_offset = bpp *
-                (fb_display[fb_info.currcon].var.xres_virtual - fb_display[fb_info.currcon].var.xres) / 16;
+                (info->var.xres_virtual - info->var.xres) / 16;
         if (par->hw.falcon.xoffset)
                 par->hw.falcon.line_offset -= bpp;
         xoffset = var->xoffset - par->hw.falcon.xoffset;
 
         par->screen_base = screen_base +
-                (var->yoffset * fb_display[fb_info.currcon].var.xres_virtual + xoffset) * bpp / 8;
+                (var->yoffset * info->var.xres_virtual + xoffset) * bpp / 8;
         if (fbhw->set_screen_base)
-                fbhw->set_screen_base (par->screen_base);
+                fbhw->set_screen_base(par->screen_base);
         else
-                return -EINVAL; /* shouldn't happen */
+                return -EINVAL;         /* shouldn't happen */
         f_pan_display = 1;
         return 0;
 }
 
-
-static int falcon_getcolreg( unsigned regno, unsigned *red,
-                                 unsigned *green, unsigned *blue,
-                                 unsigned *transp, struct fb_info *info )
-{       unsigned long col;
-        
-        if (regno > 255)
-                return 1;
-        /* This works in STE-mode (with 4bit/color) since f030_col-registers
-         * hold up to 6bit/color.
-         * Even with hicolor r/g/b=5/6/5 bit!
-         */
-        col = f030_col[regno];
-        *red = (col >> 16) & 0xff00;
-        *green = (col >> 8) & 0xff00;
-        *blue = (col << 8) & 0xff00;
-        *transp = 0;
-        return 0;
-}
-
-
-static int falcon_setcolreg( unsigned regno, unsigned red,
-                                                         unsigned green, unsigned blue,
-                                                         unsigned transp, struct fb_info *info )
+static int falcon_setcolreg(unsigned int regno, unsigned int red,
+                            unsigned int green, unsigned int blue,
+                            unsigned int transp, struct fb_info *info)
 {
         if (regno > 255)
                 return 1;
@@ -1655,13 +1744,12 @@ static int falcon_setcolreg( unsigned regno, unsigned red,
         return 0;
 }
 
-
-static int falcon_blank( int blank_mode )
+static int falcon_blank(int blank_mode)
 {
-/* ++guenther: we can switch off graphics by changing VDB and VDE,
- * so VIDEL doesn't hog the bus while saving.
- * (this may affect usleep()).
- */
+        /* ++guenther: we can switch off graphics by changing VDB and VDE,
+         * so VIDEL doesn't hog the bus while saving.
+         * (this may affect usleep()).
+         */
         int vdb, vss, hbe, hss;
 
         if (mon_type == F_MON_SM)       /* this doesn't work on SM124 */
@@ -1694,14 +1782,13 @@ static int falcon_blank( int blank_mode )
         return 0;
 }
 
- 
-static int falcon_detect( void )
+static int falcon_detect(void)
 {
         struct atafb_par par;
         unsigned char fhw;
 
         /* Determine connected monitor and set monitor parameters */
-        fhw = *(unsigned char*)0xffff8006;
+        fhw = *(unsigned char *)0xffff8006;
         mon_type = fhw >> 6 & 0x3;
         /* bit 1 of fhw: 1=32 bit ram bus, 0=16 bit */
         f030_bus_width = fhw << 6 & 0x80;
@@ -1715,7 +1802,7 @@ static int falcon_detect( void )
         case F_MON_SC:
         case F_MON_TV:
                 /* PAL...NTSC */
-                fb_info.monspecs.vfmin = 49; /* not 50, since TOS defaults to 49.9x Hz */
+                fb_info.monspecs.vfmin = 49;    /* not 50, since TOS defaults to 49.9x Hz */
                 fb_info.monspecs.vfmax = 60;
                 fb_info.monspecs.hfmin = 15620;
                 fb_info.monspecs.hfmax = 15755;
@@ -1740,13 +1827,12 @@ static int falcon_detect( void )
 
 #ifdef ATAFB_STE
 
-static int stste_encode_fix( struct fb_fix_screeninfo *fix,
-                                                         struct atafb_par *par )
-
+static int stste_encode_fix(struct fb_fix_screeninfo *fix,
+                            struct atafb_par *par)
 {
         int mode;
 
-        strcpy(fix->id,"Atari Builtin");
+        strcpy(fix->id, "Atari Builtin");
         fix->smem_start = (unsigned long)real_screen_base;
         fix->smem_len = screen_len;
         fix->type = FB_TYPE_INTERLEAVED_PLANES;
@@ -1771,43 +1857,40 @@ static int stste_encode_fix( struct fb_fix_screeninfo *fix,
         return 0;
 }
 
-
-static int stste_decode_var( struct fb_var_screeninfo *var,
-                                                  struct atafb_par *par )
+static int stste_decode_var(struct fb_var_screeninfo *var,
+                            struct atafb_par *par)
 {
-        int xres=var->xres;
-        int yres=var->yres;
-        int bpp=var->bits_per_pixel;
+        int xres = var->xres;
+        int yres = var->yres;
+        int bpp = var->bits_per_pixel;
         int linelen;
         int yres_virtual = var->yres_virtual;
 
         if (mono_moni) {
                 if (bpp > 1 || xres > sttt_xres || yres > st_yres)
                         return -EINVAL;
-                par->hw.st.mode=ST_HIGH;
-                xres=sttt_xres;
-                yres=st_yres;
-                bpp=1;
+                par->hw.st.mode = ST_HIGH;
+                xres = sttt_xres;
+                yres = st_yres;
+                bpp = 1;
         } else {
                 if (bpp > 4 || xres > sttt_xres || yres > st_yres)
                         return -EINVAL;
                 if (bpp > 2) {
-                        if (xres > sttt_xres/2 || yres > st_yres/2)
+                        if (xres > sttt_xres / 2 || yres > st_yres / 2)
                                 return -EINVAL;
-                        par->hw.st.mode=ST_LOW;
-                        xres=sttt_xres/2;
-                        yres=st_yres/2;
-                        bpp=4;
-                }
-                else if (bpp > 1) {
-                        if (xres > sttt_xres || yres > st_yres/2)
+                        par->hw.st.mode = ST_LOW;
+                        xres = sttt_xres / 2;
+                        yres = st_yres / 2;
+                        bpp = 4;
+                } else if (bpp > 1) {
+                        if (xres > sttt_xres || yres > st_yres / 2)
                                 return -EINVAL;
-                        par->hw.st.mode=ST_MID;
-                        xres=sttt_xres;
-                        yres=st_yres/2;
-                        bpp=2;
-                }
-                else
+                        par->hw.st.mode = ST_MID;
+                        xres = sttt_xres;
+                        yres = st_yres / 2;
+                        bpp = 2;
+                } else
                         return -EINVAL;
         }
         if (yres_virtual <= 0)
@@ -1815,10 +1898,10 @@ static int stste_decode_var( struct fb_var_screeninfo *var,
         else if (yres_virtual < yres)
                 yres_virtual = yres;
         if (var->sync & FB_SYNC_EXT)
-                par->hw.st.sync=(par->hw.st.sync & ~1) | 1;
+                par->hw.st.sync = (par->hw.st.sync & ~1) | 1;
         else
-                par->hw.st.sync=(par->hw.st.sync & ~1);
-        linelen=xres*bpp/8;
+                par->hw.st.sync = (par->hw.st.sync & ~1);
+        linelen = xres * bpp / 8;
         if (yres_virtual * linelen > screen_len && screen_len)
                 return -EINVAL;
         if (yres * linelen > screen_len && screen_len)
@@ -1826,93 +1909,91 @@ static int stste_decode_var( struct fb_var_screeninfo *var,
         if (var->yoffset + yres > yres_virtual && yres_virtual)
                 return -EINVAL;
         par->yres_virtual = yres_virtual;
-        par->screen_base=screen_base+ var->yoffset*linelen;
+        par->screen_base = screen_base + var->yoffset * linelen;
         return 0;
 }
 
-static int stste_encode_var( struct fb_var_screeninfo *var,
-                                                  struct atafb_par *par )
+static int stste_encode_var(struct fb_var_screeninfo *var,
+                            struct atafb_par *par)
 {
         int linelen;
         memset(var, 0, sizeof(struct fb_var_screeninfo));
-        var->red.offset=0;
+        var->red.offset = 0;
         var->red.length = ATARIHW_PRESENT(EXTD_SHIFTER) ? 4 : 3;
-        var->red.msb_right=0;
-        var->grayscale=0;
+        var->red.msb_right = 0;
+        var->grayscale = 0;
 
-        var->pixclock=31041;
-        var->left_margin=120;           /* these are incorrect */
-        var->right_margin=100;
-        var->upper_margin=8;
-        var->lower_margin=16;
-        var->hsync_len=140;
-        var->vsync_len=30;
+        var->pixclock = 31041;
+        var->left_margin = 120;         /* these are incorrect */
+        var->right_margin = 100;
+        var->upper_margin = 8;
+        var->lower_margin = 16;
+        var->hsync_len = 140;
+        var->vsync_len = 30;
 
-        var->height=-1;
-        var->width=-1;
+        var->height = -1;
+        var->width = -1;
 
         if (!(par->hw.st.sync & 1))
-                var->sync=0;
+                var->sync = 0;
         else
-                var->sync=FB_SYNC_EXT;
+                var->sync = FB_SYNC_EXT;
 
         switch (par->hw.st.mode & 3) {
         case ST_LOW:
-                var->xres=sttt_xres/2;
-                var->yres=st_yres/2;
-                var->bits_per_pixel=4;
+                var->xres = sttt_xres / 2;
+                var->yres = st_yres / 2;
+                var->bits_per_pixel = 4;
                 break;
         case ST_MID:
-                var->xres=sttt_xres;
-                var->yres=st_yres/2;
-                var->bits_per_pixel=2;
+                var->xres = sttt_xres;
+                var->yres = st_yres / 2;
+                var->bits_per_pixel = 2;
                 break;
         case ST_HIGH:
-                var->xres=sttt_xres;
-                var->yres=st_yres;
-                var->bits_per_pixel=1;
+                var->xres = sttt_xres;
+                var->yres = st_yres;
+                var->bits_per_pixel = 1;
                 break;
-        }               
-        var->blue=var->green=var->red;
-        var->transp.offset=0;
-        var->transp.length=0;
-        var->transp.msb_right=0;
-        var->xres_virtual=sttt_xres_virtual;
-        linelen=var->xres_virtual * var->bits_per_pixel / 8;
-        ovsc_addlen=linelen*(sttt_yres_virtual - st_yres);
-        
-        if (! use_hwscroll)
-                var->yres_virtual=var->yres;
+        }
+        var->blue = var->green = var->red;
+        var->transp.offset = 0;
+        var->transp.length = 0;
+        var->transp.msb_right = 0;
+        var->xres_virtual = sttt_xres_virtual;
+        linelen = var->xres_virtual * var->bits_per_pixel / 8;
+        ovsc_addlen = linelen * (sttt_yres_virtual - st_yres);
+
+        if (!use_hwscroll)
+                var->yres_virtual = var->yres;
         else if (screen_len) {
                 if (par->yres_virtual)
                         var->yres_virtual = par->yres_virtual;
                 else
-                        /* yres_virtual==0 means use maximum */
+                        /* yres_virtual == 0 means use maximum */
                         var->yres_virtual = screen_len / linelen;
-        }
-        else {
+        } else {
                 if (hwscroll < 0)
                         var->yres_virtual = 2 * var->yres;
                 else
-                        var->yres_virtual=var->yres+hwscroll * 16;
+                        var->yres_virtual = var->yres + hwscroll * 16;
         }
-        var->xoffset=0;
+        var->xoffset = 0;
         if (screen_base)
-                var->yoffset=(par->screen_base - screen_base)/linelen;
+                var->yoffset = (par->screen_base - screen_base) / linelen;
         else
-                var->yoffset=0;
-        var->nonstd=0;
-        var->activate=0;
-        var->vmode=FB_VMODE_NONINTERLACED;
+                var->yoffset = 0;
+        var->nonstd = 0;
+        var->activate = 0;
+        var->vmode = FB_VMODE_NONINTERLACED;
         return 0;
 }
 
-
-static void stste_get_par( struct atafb_par *par )
+static void stste_get_par(struct atafb_par *par)
 {
         unsigned long addr;
-        par->hw.st.mode=shifter_tt.st_shiftmode;
-        par->hw.st.sync=shifter.syncmode;
+        par->hw.st.mode = shifter_tt.st_shiftmode;
+        par->hw.st.sync = shifter.syncmode;
         addr = ((shifter.bas_hi & 0xff) << 16) |
                ((shifter.bas_md & 0xff) << 8);
         if (ATARIHW_PRESENT(EXTD_SHIFTER))
@@ -1920,55 +2001,18 @@ static void stste_get_par( struct atafb_par *par )
         par->screen_base = phys_to_virt(addr);
 }
 
-static void stste_set_par( struct atafb_par *par )
+static void stste_set_par(struct atafb_par *par)
 {
-        shifter_tt.st_shiftmode=par->hw.st.mode;
-        shifter.syncmode=par->hw.st.sync;
+        shifter_tt.st_shiftmode = par->hw.st.mode;
+        shifter.syncmode = par->hw.st.sync;
         /* only set screen_base if really necessary */
         if (current_par.screen_base != par->screen_base)
                 fbhw->set_screen_base(par->screen_base);
 }
 
-
-static int stste_getcolreg(unsigned regno, unsigned *red,
-                           unsigned *green, unsigned *blue,
-                           unsigned *transp, struct fb_info *info)
-{
-        unsigned col, t;
-        
-        if (regno > 15)
-                return 1;
-        col = shifter_tt.color_reg[regno];
-        if (ATARIHW_PRESENT(EXTD_SHIFTER)) {
-                t = ((col >> 7) & 0xe) | ((col >> 11) & 1);
-                t |= t << 4;
-                *red = t | (t << 8);
-                t = ((col >> 3) & 0xe) | ((col >> 7) & 1);
-                t |= t << 4;
-                *green = t | (t << 8);
-                t = ((col << 1) & 0xe) | ((col >> 3) & 1);
-                t |= t << 4;
-                *blue = t | (t << 8);
-        }
-        else {
-                t = (col >> 7) & 0xe;
-                t |= t << 4;
-                *red = t | (t << 8);
-                t = (col >> 3) & 0xe;
-                t |= t << 4;
-                *green = t | (t << 8);
-                t = (col << 1) & 0xe;
-                t |= t << 4;
-                *blue = t | (t << 8);
-        }
-        *transp = 0;
-        return 0;
-}
-
-
-static int stste_setcolreg(unsigned regno, unsigned red,
-                           unsigned green, unsigned blue,
-                           unsigned transp, struct fb_info *info)
+static int stste_setcolreg(unsigned int regno, unsigned int red,
+                           unsigned int green, unsigned int blue,
+                           unsigned int transp, struct fb_info *info)
 {
         if (regno > 15)
                 return 1;
@@ -1988,10 +2032,9 @@ static int stste_setcolreg(unsigned regno, unsigned red,
         return 0;
 }
 
-                                                  
-static int stste_detect( void )
-
-{       struct atafb_par par;
+static int stste_detect(void)
+{
+        struct atafb_par par;
 
         /* Determine the connected monitor: The DMA sound must be
          * disabled before reading the MFP GPIP, because the Sound
@@ -1999,7 +2042,7 @@ static int stste_detect( void )
          */
         if (ATARIHW_PRESENT(PCM_8BIT)) {
                 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
-                udelay(20);     /* wait a while for things to settle down */
+                udelay(20);             /* wait a while for things to settle down */
         }
         mono_moni = (mfp.par_dt_reg & 0x80) == 0;
 
@@ -2014,12 +2057,12 @@ static int stste_detect( void )
 static void stste_set_screen_base(void *s_base)
 {
         unsigned long addr;
-        addr= virt_to_phys(s_base);
+        addr = virt_to_phys(s_base);
         /* Setup Screen Memory */
-        shifter.bas_hi=(unsigned char) ((addr & 0xff0000) >> 16);
-        shifter.bas_md=(unsigned char) ((addr & 0x00ff00) >> 8);
+        shifter.bas_hi = (unsigned char)((addr & 0xff0000) >> 16);
+        shifter.bas_md = (unsigned char)((addr & 0x00ff00) >> 8);
         if (ATARIHW_PRESENT(EXTD_SHIFTER))
-                shifter.bas_lo=(unsigned char)  (addr & 0x0000ff);
+                shifter.bas_lo = (unsigned char)(addr & 0x0000ff);
 }
 
 #endif /* ATAFB_STE */
@@ -2045,51 +2088,49 @@ static void stste_set_screen_base(void *s_base)
 /* SWITCH_ACIA may be used for Falcon (ScreenBlaster III internal!) */
 static void st_ovsc_switch(void)
 {
-    unsigned long flags;
-    register unsigned char old, new;
+        unsigned long flags;
+        register unsigned char old, new;
 
-    if (!(atari_switches & ATARI_SWITCH_OVSC_MASK))
-        return;
-    local_irq_save(flags);
-
-    mfp.tim_ct_b = 0x10;
-    mfp.active_edge |= 8;
-    mfp.tim_ct_b = 0;
-    mfp.tim_dt_b = 0xf0;
-    mfp.tim_ct_b = 8;
-    while (mfp.tim_dt_b > 1)    /* TOS does it this way, don't ask why */
-        ;
-    new = mfp.tim_dt_b;
-    do {
-        udelay(LINE_DELAY);
-        old = new;
+        if (!(atari_switches & ATARI_SWITCH_OVSC_MASK))
+                return;
+        local_irq_save(flags);
+
+        mfp.tim_ct_b = 0x10;
+        mfp.active_edge |= 8;
+        mfp.tim_ct_b = 0;
+        mfp.tim_dt_b = 0xf0;
+        mfp.tim_ct_b = 8;
+        while (mfp.tim_dt_b > 1)        /* TOS does it this way, don't ask why */
+                ;
         new = mfp.tim_dt_b;
-    } while (old != new);
-    mfp.tim_ct_b = 0x10;
-    udelay(SYNC_DELAY);
-
-    if (atari_switches & ATARI_SWITCH_OVSC_IKBD)
-        acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID | ACIA_RIE;
-    if (atari_switches & ATARI_SWITCH_OVSC_MIDI)
-        acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID;
-    if (atari_switches & (ATARI_SWITCH_OVSC_SND6|ATARI_SWITCH_OVSC_SND7)) {
-        sound_ym.rd_data_reg_sel = 14;
-        sound_ym.wd_data = sound_ym.rd_data_reg_sel |
-                           ((atari_switches&ATARI_SWITCH_OVSC_SND6) ? 0x40:0) |
-                           ((atari_switches&ATARI_SWITCH_OVSC_SND7) ? 0x80:0);
-    }
-    local_irq_restore(flags);
+        do {
+                udelay(LINE_DELAY);
+                old = new;
+                new = mfp.tim_dt_b;
+        } while (old != new);
+        mfp.tim_ct_b = 0x10;
+        udelay(SYNC_DELAY);
+
+        if (atari_switches & ATARI_SWITCH_OVSC_IKBD)
+                acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID | ACIA_RIE;
+        if (atari_switches & ATARI_SWITCH_OVSC_MIDI)
+                acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID;
+        if (atari_switches & (ATARI_SWITCH_OVSC_SND6|ATARI_SWITCH_OVSC_SND7)) {
+                sound_ym.rd_data_reg_sel = 14;
+                sound_ym.wd_data = sound_ym.rd_data_reg_sel |
+                                   ((atari_switches & ATARI_SWITCH_OVSC_SND6) ? 0x40:0) |
+                                   ((atari_switches & ATARI_SWITCH_OVSC_SND7) ? 0x80:0);
+        }
+        local_irq_restore(flags);
 }
 
 /* ------------------- External Video ---------------------- */
 
 #ifdef ATAFB_EXT
 
-static int ext_encode_fix( struct fb_fix_screeninfo *fix,
-                                                   struct atafb_par *par )
-
+static int ext_encode_fix(struct fb_fix_screeninfo *fix, struct atafb_par *par)
 {
-        strcpy(fix->id,"Unknown Extern");
+        strcpy(fix->id, "Unknown Extern");
         fix->smem_start = (unsigned long)external_addr;
         fix->smem_len = PAGE_ALIGN(external_len);
         if (external_depth == 1) {
@@ -2099,31 +2140,29 @@ static int ext_encode_fix( struct fb_fix_screeninfo *fix,
                 fix->visual =
                         (external_pmode == FB_TYPE_INTERLEAVED_PLANES ||
                          external_pmode == FB_TYPE_PACKED_PIXELS) ?
-                                FB_VISUAL_MONO10 :
-                                        FB_VISUAL_MONO01;
-        }
-        else {
+                                FB_VISUAL_MONO10 : FB_VISUAL_MONO01;
+        } else {
                 /* Use STATIC if we don't know how to access color registers */
                 int visual = external_vgaiobase ?
                                          FB_VISUAL_PSEUDOCOLOR :
                                          FB_VISUAL_STATIC_PSEUDOCOLOR;
                 switch (external_pmode) {
-                    case -1:              /* truecolor */
-                        fix->type=FB_TYPE_PACKED_PIXELS;
-                        fix->visual=FB_VISUAL_TRUECOLOR;
+                case -1:                /* truecolor */
+                        fix->type = FB_TYPE_PACKED_PIXELS;
+                        fix->visual = FB_VISUAL_TRUECOLOR;
                         break;
-                    case FB_TYPE_PACKED_PIXELS:
-                        fix->type=FB_TYPE_PACKED_PIXELS;
-                        fix->visual=visual;
+                case FB_TYPE_PACKED_PIXELS:
+                        fix->type = FB_TYPE_PACKED_PIXELS;
+                        fix->visual = visual;
                         break;
-                    case FB_TYPE_PLANES:
-                        fix->type=FB_TYPE_PLANES;
-                        fix->visual=visual;
+                case FB_TYPE_PLANES:
+                        fix->type = FB_TYPE_PLANES;
+                        fix->visual = visual;
                         break;
-                    case FB_TYPE_INTERLEAVED_PLANES:
-                        fix->type=FB_TYPE_INTERLEAVED_PLANES;
-                        fix->type_aux=2;
-                        fix->visual=visual;
+                case FB_TYPE_INTERLEAVED_PLANES:
+                        fix->type = FB_TYPE_INTERLEAVED_PLANES;
+                        fix->type_aux = 2;
+                        fix->visual = visual;
                         break;
                 }
         }
@@ -2134,137 +2173,112 @@ static int ext_encode_fix( struct fb_fix_screeninfo *fix,
         return 0;
 }
 
-
-static int ext_decode_var( struct fb_var_screeninfo *var,
-                                                   struct atafb_par *par )
+static int ext_decode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
 {
         struct fb_var_screeninfo *myvar = &atafb_predefined[0];
-        
+
         if (var->bits_per_pixel > myvar->bits_per_pixel ||
-                var->xres > myvar->xres ||
-                var->xres_virtual > myvar->xres_virtual ||
-                var->yres > myvar->yres ||
-                var->xoffset > 0 ||
-                var->yoffset > 0)
+            var->xres > myvar->xres ||
+            var->xres_virtual > myvar->xres_virtual ||
+            var->yres > myvar->yres ||
+            var->xoffset > 0 ||
+            var->yoffset > 0)
                 return -EINVAL;
         return 0;
 }
 
-
-static int ext_encode_var( struct fb_var_screeninfo *var,
-                                                   struct atafb_par *par )
+static int ext_encode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
 {
         memset(var, 0, sizeof(struct fb_var_screeninfo));
-        var->red.offset=0;
-        var->red.length=(external_pmode == -1) ? external_depth/3 : 
+        var->red.offset = 0;
+        var->red.length = (external_pmode == -1) ? external_depth / 3 :
                         (external_vgaiobase ? external_bitspercol : 0);
-        var->red.msb_right=0;
-        var->grayscale=0;
+        var->red.msb_right = 0;
+        var->grayscale = 0;
 
-        var->pixclock=31041;
-        var->left_margin=120;           /* these are surely incorrect   */
-        var->right_margin=100;
-        var->upper_margin=8;
-        var->lower_margin=16;
-        var->hsync_len=140;
-        var->vsync_len=30;
+        var->pixclock = 31041;
+        var->left_margin = 120;         /* these are surely incorrect */
+        var->right_margin = 100;
+        var->upper_margin = 8;
+        var->lower_margin = 16;
+        var->hsync_len = 140;
+        var->vsync_len = 30;
 
-        var->height=-1;
-        var->width=-1;
+        var->height = -1;
+        var->width = -1;
 
-        var->sync=0;
+        var->sync = 0;
 
         var->xres = external_xres;
         var->yres = external_yres;
         var->xres_virtual = external_xres_virtual;
         var->bits_per_pixel = external_depth;
-        
-        var->blue=var->green=var->red;
-        var->transp.offset=0;
-        var->transp.length=0;
-        var->transp.msb_right=0;
-        var->yres_virtual=var->yres;
-        var->xoffset=0;
-        var->yoffset=0;
-        var->nonstd=0;
-        var->activate=0;
-        var->vmode=FB_VMODE_NONINTERLACED;
+
+        var->blue = var->green = var->red;
+        var->transp.offset = 0;
+        var->transp.length = 0;
+        var->transp.msb_right = 0;
+        var->yres_virtual = var->yres;
+        var->xoffset = 0;
+        var->yoffset = 0;
+        var->nonstd = 0;
+        var->activate = 0;
+        var->vmode = FB_VMODE_NONINTERLACED;
         return 0;
 }
 
-
-static void ext_get_par( struct atafb_par *par )
+static void ext_get_par(struct atafb_par *par)
 {
         par->screen_base = external_addr;
 }
 
-static void ext_set_par( struct atafb_par *par )
+static void ext_set_par(struct atafb_par *par)
 {
 }
 
 #define OUTB(port,val) \
-        *((unsigned volatile char *) ((port)+external_vgaiobase))=(val)
+        *((unsigned volatile char *) ((port)+external_vgaiobase)) = (val)
 #define INB(port) \
         (*((unsigned volatile char *) ((port)+external_vgaiobase)))
-#define DACDelay                                \
+#define DACDelay                                \
         do {                                    \
-                unsigned char tmp=INB(0x3da);   \
-                tmp=INB(0x3da);                 \
+                unsigned char tmp = INB(0x3da); \
+                tmp = INB(0x3da);                       \
         } while (0)
 
-static int ext_getcolreg( unsigned regno, unsigned *red,
-                                                  unsigned *green, unsigned *blue,
-                                                  unsigned *transp, struct fb_info *info )
+static int ext_setcolreg(unsigned int regno, unsigned int red,
+                         unsigned int green, unsigned int blue,
+                         unsigned int transp, struct fb_info *info)
 {
-        if (! external_vgaiobase)
+        unsigned char colmask = (1 << external_bitspercol) - 1;
+
+        if (!external_vgaiobase)
                 return 1;
 
-            *red   = ext_color[regno].red;
-            *green = ext_color[regno].green;
-            *blue  = ext_color[regno].blue;
-            *transp=0;
-            return 0;
-}
-        
-static int ext_setcolreg( unsigned regno, unsigned red,
-                                                  unsigned green, unsigned blue,
-                                                  unsigned transp, struct fb_info *info )
+        switch (external_card_type) {
+        case IS_VGA:
+                OUTB(0x3c8, regno);
+                DACDelay;
+                OUTB(0x3c9, red & colmask);
+                DACDelay;
+                OUTB(0x3c9, green & colmask);
+                DACDelay;
+                OUTB(0x3c9, blue & colmask);
+                DACDelay;
+                return 0;
 
-{       unsigned char colmask = (1 << external_bitspercol) - 1;
+        case IS_MV300:
+                OUTB((MV300_reg[regno] << 2) + 1, red);
+                OUTB((MV300_reg[regno] << 2) + 1, green);
+                OUTB((MV300_reg[regno] << 2) + 1, blue);
+                return 0;
 
-        if (! external_vgaiobase)
+        default:
                 return 1;
-
-        ext_color[regno].red = red;
-        ext_color[regno].green = green;
-        ext_color[regno].blue = blue;
-
-        switch (external_card_type) {
-          case IS_VGA:
-            OUTB(0x3c8, regno);
-            DACDelay;
-            OUTB(0x3c9, red & colmask);
-            DACDelay;
-            OUTB(0x3c9, green & colmask);
-            DACDelay;
-            OUTB(0x3c9, blue & colmask);
-            DACDelay;
-            return 0;
-
-          case IS_MV300:
-            OUTB((MV300_reg[regno] << 2)+1, red);
-            OUTB((MV300_reg[regno] << 2)+1, green);
-            OUTB((MV300_reg[regno] << 2)+1, blue);
-            return 0;
-
-          default:
-            return 1;
-          }
+        }
 }
-        
-
-static int ext_detect( void )
 
+static int ext_detect(void)
 {
         struct fb_var_screeninfo *myvar = &atafb_predefined[0];
         struct atafb_par dummy_par;
@@ -2284,213 +2298,182 @@ static int ext_detect( void )
 static void set_screen_base(void *s_base)
 {
         unsigned long addr;
-        addr= virt_to_phys(s_base);
+
+        addr = virt_to_phys(s_base);
         /* Setup Screen Memory */
-        shifter.bas_hi=(unsigned char) ((addr & 0xff0000) >> 16);
-        shifter.bas_md=(unsigned char) ((addr & 0x00ff00) >> 8);
-        shifter.bas_lo=(unsigned char)  (addr & 0x0000ff);
+        shifter.bas_hi = (unsigned char)((addr & 0xff0000) >> 16);
+        shifter.bas_md = (unsigned char)((addr & 0x00ff00) >> 8);
+        shifter.bas_lo = (unsigned char)(addr & 0x0000ff);
 }
 
-
-static int pan_display( struct fb_var_screeninfo *var,
-                        struct atafb_par *par )
+static int pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 {
+        struct atafb_par *par = (struct atafb_par *)info->par;
+
         if (!fbhw->set_screen_base ||
-                (!ATARIHW_PRESENT(EXTD_SHIFTER) && var->xoffset))
+            (!ATARIHW_PRESENT(EXTD_SHIFTER) && var->xoffset))
                 return -EINVAL;
         var->xoffset = up(var->xoffset, 16);
         par->screen_base = screen_base +
-                (var->yoffset * fb_display[fb_info.currcon].var.xres_virtual + var->xoffset)
-                * fb_display[fb_info.currcon].var.bits_per_pixel / 8;
-        fbhw->set_screen_base (par->screen_base);
+                (var->yoffset * info->var.xres_virtual + var->xoffset)
+                * info->var.bits_per_pixel / 8;
+        fbhw->set_screen_base(par->screen_base);
         return 0;
 }
 
-
 /* ------------ Interfaces to hardware functions ------------ */
 
-
 #ifdef ATAFB_TT
 static struct fb_hwswitch tt_switch = {
-        tt_detect, tt_encode_fix, tt_decode_var, tt_encode_var,
-        tt_get_par, tt_set_par, tt_getcolreg, 
-        set_screen_base, NULL, pan_display
+        .detect         = tt_detect,
+        .encode_fix     = tt_encode_fix,
+        .decode_var     = tt_decode_var,
+        .encode_var     = tt_encode_var,
+        .get_par        = tt_get_par,
+        .set_par        = tt_set_par,
+        .set_screen_base = set_screen_base,
+        .pan_display    = pan_display,
 };
 #endif
 
 #ifdef ATAFB_FALCON
 static struct fb_hwswitch falcon_switch = {
-        falcon_detect, falcon_encode_fix, falcon_decode_var, falcon_encode_var,
-        falcon_get_par, falcon_set_par, falcon_getcolreg,
-        set_screen_base, falcon_blank, falcon_pan_display
+        .detect         = falcon_detect,
+        .encode_fix     = falcon_encode_fix,
+        .decode_var     = falcon_decode_var,
+        .encode_var     = falcon_encode_var,
+        .get_par        = falcon_get_par,
+        .set_par        = falcon_set_par,
+        .set_screen_base = set_screen_base,
+        .blank          = falcon_blank,
+        .pan_display    = falcon_pan_display,
 };
 #endif
 
 #ifdef ATAFB_STE
 static struct fb_hwswitch st_switch = {
-        stste_detect, stste_encode_fix, stste_decode_var, stste_encode_var,
-        stste_get_par, stste_set_par, stste_getcolreg,
-        stste_set_screen_base, NULL, pan_display
+        .detect         = stste_detect,
+        .encode_fix     = stste_encode_fix,
+        .decode_var     = stste_decode_var,
+        .encode_var     = stste_encode_var,
+        .get_par        = stste_get_par,
+        .set_par        = stste_set_par,
+        .set_screen_base = stste_set_screen_base,
+        .pan_display    = pan_display
 };
 #endif
 
 #ifdef ATAFB_EXT
 static struct fb_hwswitch ext_switch = {
-        ext_detect, ext_encode_fix, ext_decode_var, ext_encode_var,
-        ext_get_par, ext_set_par, ext_getcolreg, NULL, NULL, NULL
+        .detect         = ext_detect,
+        .encode_fix     = ext_encode_fix,
+        .decode_var     = ext_decode_var,
+        .encode_var     = ext_encode_var,
+        .get_par        = ext_get_par,
+        .set_par        = ext_set_par,
 };
 #endif
 
-
-
-static void atafb_get_par( struct atafb_par *par )
+static void ata_get_par(struct atafb_par *par)
 {
-        if (current_par_valid) {
-                *par=current_par;
-        }
+        if (current_par_valid)
+                *par = current_par;
         else
                 fbhw->get_par(par);
 }
 
-
-static void atafb_set_par( struct atafb_par *par )
+static void ata_set_par(struct atafb_par *par)
 {
         fbhw->set_par(par);
-        current_par=*par;
-        current_par_valid=1;
+        current_par = *par;
+        current_par_valid = 1;
 }
 
 
-
 /* =========================================================== */
 /* ============== Hardware Independent Functions ============= */
 /* =========================================================== */
 
-
 /* used for hardware scrolling */
 
-static int
-fb_update_var(int con, struct fb_info *info)
-{
-        int off=fb_display[con].var.yoffset*fb_display[con].var.xres_virtual*
-                        fb_display[con].var.bits_per_pixel>>3;
-
-        current_par.screen_base=screen_base + off;
-
-        if (fbhw->set_screen_base)
-                fbhw->set_screen_base(current_par.screen_base);
-        return 0;
-}
-
-static int
-do_fb_set_var(struct fb_var_screeninfo *var, int isactive)
+static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive)
 {
-        int err,activate;
+        int err, activate;
         struct atafb_par par;
-        if ((err=fbhw->decode_var(var, &par)))
+
+        err = fbhw->decode_var(var, &par);
+        if (err)
                 return err;
-        activate=var->activate;
+        activate = var->activate;
         if (((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive)
-                atafb_set_par(&par);
+                ata_set_par(&par);
         fbhw->encode_var(var, &par);
-        var->activate=activate;
+        var->activate = activate;
         return 0;
 }
 
-static int
-atafb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
+static int atafb_get_fix(struct fb_fix_screeninfo *fix, struct fb_info *info)
 {
         struct atafb_par par;
-        if (con == -1)
-                atafb_get_par(&par);
-        else {
-          int err;
-                if ((err=fbhw->decode_var(&fb_display[con].var,&par)))
-                  return err;
-        }
+        int err;
+        // Get fix directly (case con == -1 before)??
+        err = fbhw->decode_var(&info->var, &par);
+        if (err)
+                return err;
         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
         return fbhw->encode_fix(fix, &par);
 }
-        
-static int
-atafb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
+
+static int atafb_get_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
         struct atafb_par par;
-        if (con == -1) {
-                atafb_get_par(&par);
-                fbhw->encode_var(var, &par);
-        }
-        else
-                *var=fb_display[con].var;
+
+        ata_get_par(&par);
+        fbhw->encode_var(var, &par);
+
         return 0;
 }
 
-static void
-atafb_set_disp(int con, struct fb_info *info)
+// No longer called by fbcon!
+// Still called by set_var internally
+
+static void atafb_set_disp(struct fb_info *info)
 {
-        struct fb_fix_screeninfo fix;
-        struct fb_var_screeninfo var;
-        struct display *display;
+        atafb_get_var(&info->var, info);
+        atafb_get_fix(&info->fix, info);
 
-        if (con >= 0)
-                display = &fb_display[con];
-        else
-                display = &disp;        /* used during initialization */
-
-        atafb_get_fix(&fix, con, info);
-        atafb_get_var(&var, con, info);
-        if (con == -1)
-                con=0;
-        info->screen_base = (void *)fix.smem_start;
-        display->visual = fix.visual;
-        display->type = fix.type;
-        display->type_aux = fix.type_aux;
-        display->ypanstep = fix.ypanstep;
-        display->ywrapstep = fix.ywrapstep;
-        display->line_length = fix.line_length;
-        if (fix.visual != FB_VISUAL_PSEUDOCOLOR &&
-                fix.visual != FB_VISUAL_DIRECTCOLOR)
-                display->can_soft_blank = 0;
-        else
-                display->can_soft_blank = 1;
-        display->inverse =
-            (fix.visual == FB_VISUAL_MONO01 ? !inverse : inverse);
-        switch (fix.type) {
-            case FB_TYPE_INTERLEAVED_PLANES:
-                switch (var.bits_per_pixel) {
-#ifdef FBCON_HAS_IPLAN2P2
-                    case 2:
-                        display->dispsw = &fbcon_iplan2p2;
+        info->screen_base = (void *)info->fix.smem_start;
+
+        switch (info->fix.type) {
+        case FB_TYPE_INTERLEAVED_PLANES:
+                switch (info->var.bits_per_pixel) {
+                case 2:
+                        // display->dispsw = &fbcon_iplan2p2;
                         break;
-#endif
-#ifdef FBCON_HAS_IPLAN2P4
-                    case 4:
-                        display->dispsw = &fbcon_iplan2p4;
+                case 4:
+                        // display->dispsw = &fbcon_iplan2p4;
                         break;
-#endif
-#ifdef FBCON_HAS_IPLAN2P8
-                    case 8:
-                        display->dispsw = &fbcon_iplan2p8;
+                case 8:
+                        // display->dispsw = &fbcon_iplan2p8;
                         break;
-#endif
                 }
                 break;
-            case FB_TYPE_PACKED_PIXELS:
-                switch (var.bits_per_pixel) {
+        case FB_TYPE_PACKED_PIXELS:
+                switch (info->var.bits_per_pixel) {
 #ifdef FBCON_HAS_MFB
-                    case 1:
-                        display->dispsw = &fbcon_mfb;
+                case 1:
+                        // display->dispsw = &fbcon_mfb;
                         break;
 #endif
 #ifdef FBCON_HAS_CFB8
-                    case 8:
-                        display->dispsw = &fbcon_cfb8;
+                case 8:
+                        // display->dispsw = &fbcon_cfb8;
                         break;
 #endif
 #ifdef FBCON_HAS_CFB16
-                    case 16:
-                        display->dispsw = &fbcon_cfb16;
-                        display->dispsw_data = fbcon_cfb16_cmap;
+                case 16:
+                        // display->dispsw = &fbcon_cfb16;
+                        // display->dispsw_data = fbcon_cfb16_cmap;
                         break;
 #endif
                 }
@@ -2498,74 +2481,203 @@ atafb_set_disp(int con, struct fb_info *info)
         }
 }
 
+static int atafb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
+                           u_int transp, struct fb_info *info)
+{
+        red >>= 8;
+        green >>= 8;
+        blue >>= 8;
+
+        return info->fbops->fb_setcolreg(regno, red, green, blue, transp, info);
+}
+
 static int
-atafb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
+atafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 {
-        int err,oldxres,oldyres,oldbpp,oldxres_virtual,
-            oldyres_virtual,oldyoffset;
-        if ((err=do_fb_set_var(var, con==info->currcon)))
-                return err;
-        if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
-                oldxres=fb_display[con].var.xres;
-                oldyres=fb_display[con].var.yres;
-                oldxres_virtual=fb_display[con].var.xres_virtual;
-                oldyres_virtual=fb_display[con].var.yres_virtual;
-                oldbpp=fb_display[con].var.bits_per_pixel;
-                oldyoffset=fb_display[con].var.yoffset;
-                fb_display[con].var=*var;
-                if (oldxres != var->xres || oldyres != var->yres 
-                    || oldxres_virtual != var->xres_virtual
-                    || oldyres_virtual != var->yres_virtual
-                    || oldbpp != var->bits_per_pixel
-                    || oldyoffset != var->yoffset) {
-                        atafb_set_disp(con, info);
-                        (*fb_info.changevar)(con);
-                        fb_alloc_cmap(&fb_display[con].cmap, 0, 0);
-                        do_install_cmap(con, info);
-                }
+        int xoffset = var->xoffset;
+        int yoffset = var->yoffset;
+        int err;
+
+        if (var->vmode & FB_VMODE_YWRAP) {
+                if (yoffset < 0 || yoffset >= info->var.yres_virtual || xoffset)
+                        return -EINVAL;
+        } else {
+                if (xoffset + info->var.xres > info->var.xres_virtual ||
+                    yoffset + info->var.yres > info->var.yres_virtual)
+                        return -EINVAL;
         }
-        var->activate=0;
+
+        if (fbhw->pan_display) {
+                err = fbhw->pan_display(var, info);
+                if (err)
+                        return err;
+        } else
+                return -EINVAL;
+
+        info->var.xoffset = xoffset;
+        info->var.yoffset = yoffset;
+
+        if (var->vmode & FB_VMODE_YWRAP)
+                info->var.vmode |= FB_VMODE_YWRAP;
+        else
+                info->var.vmode &= ~FB_VMODE_YWRAP;
+
         return 0;
 }
 
+/*
+ * generic drawing routines; imageblit needs updating for image depth > 1
+ */
 
+#if BITS_PER_LONG == 32
+#define BYTES_PER_LONG  4
+#define SHIFT_PER_LONG  5
+#elif BITS_PER_LONG == 64
+#define BYTES_PER_LONG  8
+#define SHIFT_PER_LONG  6
+#else
+#define Please update me
+#endif
 
-static int
-atafb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
+
+static void atafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 {
-        if (con == info->currcon) /* current console ? */
-                return fb_get_cmap(cmap, kspc, fbhw->getcolreg, info);
+        struct atafb_par *par = (struct atafb_par *)info->par;
+        int x2, y2;
+        u32 width, height;
+
+        if (!rect->width || !rect->height)
+                return;
+
+        /*
+         * We could use hardware clipping but on many cards you get around
+         * hardware clipping by writing to framebuffer directly.
+         * */
+        x2 = rect->dx + rect->width;
+        y2 = rect->dy + rect->height;
+        x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
+        y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
+        width = x2 - rect->dx;
+        height = y2 - rect->dy;
+
+        if (info->var.bits_per_pixel == 1)
+                atafb_mfb_fillrect(info, par->next_line, rect->color,
+                                   rect->dy, rect->dx, height, width);
+        else if (info->var.bits_per_pixel == 2)
+                atafb_iplan2p2_fillrect(info, par->next_line, rect->color,
+                                        rect->dy, rect->dx, height, width);
+        else if (info->var.bits_per_pixel == 4)
+                atafb_iplan2p4_fillrect(info, par->next_line, rect->color,
+                                        rect->dy, rect->dx, height, width);
         else
-                if (fb_display[con].cmap.len) /* non default colormap ? */
-                        fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
-                else
-                        fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
-                                     cmap, kspc ? 0 : 2);
-        return 0;
+                atafb_iplan2p8_fillrect(info, par->next_line, rect->color,
+                                        rect->dy, rect->dx, height, width);
+
+        return;
 }
 
-static int
-atafb_pan_display(struct fb_var_screeninfo *var, int con, struct fb_info *info)
+static void atafb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
 {
-        int xoffset = var->xoffset;
-        int yoffset = var->yoffset;
-        int err;
+        struct atafb_par *par = (struct atafb_par *)info->par;
+        int x2, y2;
+        u32 dx, dy, sx, sy, width, height;
+        int rev_copy = 0;
+
+        /* clip the destination */
+        x2 = area->dx + area->width;
+        y2 = area->dy + area->height;
+        dx = area->dx > 0 ? area->dx : 0;
+        dy = area->dy > 0 ? area->dy : 0;
+        x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
+        y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
+        width = x2 - dx;
+        height = y2 - dy;
+
+        /* update sx,sy */
+        sx = area->sx + (dx - area->dx);
+        sy = area->sy + (dy - area->dy);
+
+        /* the source must be completely inside the virtual screen */
+        if (sx < 0 || sy < 0 || (sx + width) > info->var.xres_virtual ||
+            (sy + height) > info->var.yres_virtual)
+                return;
 
-        if (   xoffset < 0 || xoffset + fb_display[con].var.xres > fb_display[con].var.xres_virtual
-            || yoffset < 0 || yoffset + fb_display[con].var.yres > fb_display[con].var.yres_virtual)
-                return -EINVAL;
+        if (dy > sy || (dy == sy && dx > sx)) {
+                dy += height;
+                sy += height;
+                rev_copy = 1;
+        }
+
+        if (info->var.bits_per_pixel == 1)
+                atafb_mfb_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
+        else if (info->var.bits_per_pixel == 2)
+                atafb_iplan2p2_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
+        else if (info->var.bits_per_pixel == 4)
+                atafb_iplan2p4_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
+        else
+                atafb_iplan2p8_copyarea(info, par->next_line, sy, sx, dy, dx, height, width);
 
-        if (con == info->currcon) {
-                if (fbhw->pan_display) {
-                        if ((err = fbhw->pan_display(var, &current_par)))
-                                return err;
+        return;
+}
+
+static void atafb_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        struct atafb_par *par = (struct atafb_par *)info->par;
+        int x2, y2;
+        unsigned long *dst;
+        int dst_idx;
+        const char *src;
+        u32 dx, dy, width, height, pitch;
+
+        /*
+         * We could use hardware clipping but on many cards you get around
+         * hardware clipping by writing to framebuffer directly like we are
+         * doing here.
+         */
+        x2 = image->dx + image->width;
+        y2 = image->dy + image->height;
+        dx = image->dx;
+        dy = image->dy;
+        x2 = x2 < info->var.xres_virtual ? x2 : info->var.xres_virtual;
+        y2 = y2 < info->var.yres_virtual ? y2 : info->var.yres_virtual;
+        width = x2 - dx;
+        height = y2 - dy;
+
+        if (image->depth == 1) {
+                // used for font data
+                dst = (unsigned long *)
+                        ((unsigned long)info->screen_base & ~(BYTES_PER_LONG - 1));
+                dst_idx = ((unsigned long)info->screen_base & (BYTES_PER_LONG - 1)) * 8;
+                dst_idx += dy * par->next_line * 8 + dx;
+                src = image->data;
+                pitch = (image->width + 7) / 8;
+                while (height--) {
+
+                        if (info->var.bits_per_pixel == 1)
+                                atafb_mfb_linefill(info, par->next_line,
+                                                   dy, dx, width, src,
+                                                   image->bg_color, image->fg_color);
+                        else if (info->var.bits_per_pixel == 2)
+                                atafb_iplan2p2_linefill(info, par->next_line,
+                                                        dy, dx, width, src,
+                                                        image->bg_color, image->fg_color);
+                        else if (info->var.bits_per_pixel == 4)
+                                atafb_iplan2p4_linefill(info, par->next_line,
+                                                        dy, dx, width, src,
+                                                        image->bg_color, image->fg_color);
+                        else
+                                atafb_iplan2p8_linefill(info, par->next_line,
+                                                        dy, dx, width, src,
+                                                        image->bg_color, image->fg_color);
+                        dy++;
+                        src += pitch;
                 }
-                else
-                        return -EINVAL;
+        } else {
+                // only used for logo; broken
+                c2p(info->screen_base, image->data, dx, dy, width, height,
+                    par->next_line, par->next_plane, image->width,
+                    info->var.bits_per_pixel);
         }
-        fb_display[con].var.xoffset = var->xoffset;
-        fb_display[con].var.yoffset = var->yoffset;
-        return 0;
 }
 
 static int
@@ -2584,7 +2696,7 @@ atafb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
                 if (copy_from_user((void *)&current_par, (void *)arg,
                                    sizeof(struct atafb_par)))
                         return -EFAULT;
-                atafb_set_par(&current_par);
+                ata_set_par(&current_par);
                 return 0;
 #endif
         }
@@ -2598,42 +2710,82 @@ atafb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
  * 3 = suspend hsync
  * 4 = off
  */
-static int 
-atafb_blank(int blank, struct fb_info *info)
+static int atafb_blank(int blank, struct fb_info *info)
 {
         unsigned short black[16];
         struct fb_cmap cmap;
         if (fbhw->blank && !fbhw->blank(blank))
                 return 1;
         if (blank) {
-                memset(black, 0, 16*sizeof(unsigned short));
-                cmap.red=black;
-                cmap.green=black;
-                cmap.blue=black;
-                cmap.transp=NULL;
-                cmap.start=0;
-                cmap.len=16;
-                fb_set_cmap(&cmap, 1, info);
+                memset(black, 0, 16 * sizeof(unsigned short));
+                cmap.red = black;
+                cmap.green = black;
+                cmap.blue = black;
+                cmap.transp = NULL;
+                cmap.start = 0;
+                cmap.len = 16;
+                fb_set_cmap(&cmap, info);
         }
+#if 0
         else
-                do_install_cmap(info->currcon, info);
+                do_install_cmap(info);
+#endif
+        return 0;
+}
+
+        /*
+         * New fbcon interface ...
+         */
+
+         /* check var by decoding var into hw par, rounding if necessary,
+          * then encoding hw par back into new, validated var */
+static int atafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        int err;
+        struct atafb_par par;
+
+        /* Validate wanted screen parameters */
+        // if ((err = ata_decode_var(var, &par)))
+        err = fbhw->decode_var(var, &par);
+        if (err)
+                return err;
+
+        /* Encode (possibly rounded) screen parameters */
+        fbhw->encode_var(var, &par);
+        return 0;
+}
+
+        /* actually set hw par by decoding var, then setting hardware from
+         * hw par just decoded */
+static int atafb_set_par(struct fb_info *info)
+{
+        struct atafb_par *par = (struct atafb_par *)info->par;
+
+        /* Decode wanted screen parameters */
+        fbhw->decode_var(&info->var, par);
+        fbhw->encode_fix(&info->fix, par);
+
+        /* Set new videomode */
+        ata_set_par(par);
+
         return 0;
 }
 
+
 static struct fb_ops atafb_ops = {
         .owner =        THIS_MODULE,
-        .fb_get_fix =   atafb_get_fix,
-        .fb_get_var =   atafb_get_var,
-        .fb_set_var =   atafb_set_var,
-        .fb_get_cmap =  atafb_get_cmap,
-        .fb_set_cmap =  gen_set_cmap,
-        .fb_pan_display =atafb_pan_display,
+        .fb_check_var   = atafb_check_var,
+        .fb_set_par     = atafb_set_par,
+        .fb_setcolreg   = atafb_setcolreg,
         .fb_blank =     atafb_blank,
+        .fb_pan_display = atafb_pan_display,
+        .fb_fillrect    = atafb_fillrect,
+        .fb_copyarea    = atafb_copyarea,
+        .fb_imageblit   = atafb_imageblit,
         .fb_ioctl =     atafb_ioctl,
 };
 
-static void
-check_default_par( int detected_mode )
+static void check_default_par(int detected_mode)
 {
         char default_name[10];
         int i;
@@ -2642,199 +2794,41 @@ check_default_par( int detected_mode )
 
         /* First try the user supplied mode */
         if (default_par) {
-                var=atafb_predefined[default_par-1];
+                var = atafb_predefined[default_par - 1];
                 var.activate = FB_ACTIVATE_TEST;
-                if (do_fb_set_var(&var,1))
-                        default_par=0;          /* failed */
+                if (do_fb_set_var(&var, 1))
+                        default_par = 0;        /* failed */
         }
         /* Next is the autodetected one */
-        if (! default_par) {
-                var=atafb_predefined[detected_mode-1]; /* autodetect */
+        if (!default_par) {
+                var = atafb_predefined[detected_mode - 1]; /* autodetect */
                 var.activate = FB_ACTIVATE_TEST;
-                if (!do_fb_set_var(&var,1))
-                        default_par=detected_mode;
+                if (!do_fb_set_var(&var, 1))
+                        default_par = detected_mode;
         }
         /* If that also failed, try some default modes... */
-        if (! default_par) {
+        if (!default_par) {
                 /* try default1, default2... */
-                for (i=1 ; i < 10 ; i++) {
-                        sprintf(default_name,"default%d",i);
-                        default_par=get_video_mode(default_name);
-                        if (! default_par)
+                for (i = 1; i < 10; i++) {
+                        sprintf(default_name,"default%d", i);
+                        default_par = get_video_mode(default_name);
+                        if (!default_par)
                                 panic("can't set default video mode");
-                        var=atafb_predefined[default_par-1];
+                        var = atafb_predefined[default_par - 1];
                         var.activate = FB_ACTIVATE_TEST;
-                        if (! do_fb_set_var(&var,1))
+                        if (!do_fb_set_var(&var,1))
                                 break;  /* ok */
                 }
         }
-        min_mem=var.xres_virtual * var.yres_virtual * var.bits_per_pixel/8;
+        min_mem = var.xres_virtual * var.yres_virtual * var.bits_per_pixel / 8;
         if (default_mem_req < min_mem)
-                default_mem_req=min_mem;
-}
-
-static int
-atafb_switch(int con, struct fb_info *info)
-{
-        /* Do we have to save the colormap ? */
-        if (fb_display[info->currcon].cmap.len)
-                fb_get_cmap(&fb_display[info->currcon].cmap, 1, fbhw->getcolreg,
-                            info);
-        do_fb_set_var(&fb_display[con].var,1);
-        info->currcon=con;
-        /* Install new colormap */
-        do_install_cmap(con, info);
-        return 0;
-}
-
-int __init atafb_init(void)
-{
-        int pad;
-        int detected_mode;
-        unsigned long mem_req;
-
-        if (!MACH_IS_ATARI)
-                return -ENXIO;
-
-        do {
-#ifdef ATAFB_EXT
-                if (external_addr) {
-                        fbhw = &ext_switch;
-                        atafb_ops.fb_setcolreg = &ext_setcolreg;
-                        break;
-                }
-#endif
-#ifdef ATAFB_TT
-                if (ATARIHW_PRESENT(TT_SHIFTER)) {
-                        fbhw = &tt_switch;
-                        atafb_ops.fb_setcolreg = &tt_setcolreg;
-                        break;
-                }
-#endif
-#ifdef ATAFB_FALCON
-                if (ATARIHW_PRESENT(VIDEL_SHIFTER)) {
-                        fbhw = &falcon_switch;
-                        atafb_ops.fb_setcolreg = &falcon_setcolreg;
-                        request_irq(IRQ_AUTO_4, falcon_vbl_switcher, IRQ_TYPE_PRIO,
-                                    "framebuffer/modeswitch", falcon_vbl_switcher);
-                        break;
-                }
-#endif
-#ifdef ATAFB_STE
-                if (ATARIHW_PRESENT(STND_SHIFTER) ||
-                    ATARIHW_PRESENT(EXTD_SHIFTER)) {
-                        fbhw = &st_switch;
-                        atafb_ops.fb_setcolreg = &stste_setcolreg;
-                        break;
-                }
-                fbhw = &st_switch;
-                atafb_ops.fb_setcolreg = &stste_setcolreg;
-                printk("Cannot determine video hardware; defaulting to ST(e)\n");
-#else /* ATAFB_STE */
-                /* no default driver included */
-                /* Nobody will ever see this message :-) */
-                panic("Cannot initialize video hardware");
-#endif
-        } while (0);
-
-        /* Multisync monitor capabilities */
-        /* Atari-TOS defaults if no boot option present */
-        if (fb_info.monspecs.hfmin == 0) {
-            fb_info.monspecs.hfmin = 31000;
-            fb_info.monspecs.hfmax = 32000;
-            fb_info.monspecs.vfmin = 58;
-            fb_info.monspecs.vfmax = 62;
-        }
-
-        detected_mode = fbhw->detect();
-        check_default_par(detected_mode);
-#ifdef ATAFB_EXT
-        if (!external_addr) {
-#endif /* ATAFB_EXT */
-                mem_req = default_mem_req + ovsc_offset + ovsc_addlen;
-                mem_req = PAGE_ALIGN(mem_req) + PAGE_SIZE;
-                screen_base = atari_stram_alloc(mem_req, "atafb");
-                if (!screen_base)
-                        panic("Cannot allocate screen memory");
-                memset(screen_base, 0, mem_req);
-                pad = -(unsigned long)screen_base & (PAGE_SIZE-1);
-                screen_base+=pad;
-                real_screen_base=screen_base+ovsc_offset;
-                screen_len = (mem_req - pad - ovsc_offset) & PAGE_MASK;
-                st_ovsc_switch();
-                if (CPU_IS_040_OR_060) {
-                        /* On a '040+, the cache mode of video RAM must be set to
-                         * write-through also for internal video hardware! */
-                        cache_push(virt_to_phys(screen_base), screen_len);
-                        kernel_set_cachemode(screen_base, screen_len,
-                                             IOMAP_WRITETHROUGH);
-                }
-#ifdef ATAFB_EXT
-        }
-        else {
-                /* Map the video memory (physical address given) to somewhere
-                 * in the kernel address space.
-                 */
-                external_addr =
-                  ioremap_writethrough((unsigned long)external_addr,
-                                       external_len);
-                if (external_vgaiobase)
-                        external_vgaiobase =
-                          (unsigned long)ioremap(external_vgaiobase, 0x10000);
-                screen_base      =
-                real_screen_base = external_addr;
-                screen_len       = external_len & PAGE_MASK;
-                memset (screen_base, 0, external_len);
-        }
-#endif /* ATAFB_EXT */
-
-        strcpy(fb_info.modename, "Atari Builtin ");
-        fb_info.changevar = NULL;
-        fb_info.fbops = &atafb_ops;
-        fb_info.disp = &disp;
-        fb_info.currcon = -1;
-        fb_info.switch_con = &atafb_switch;
-        fb_info.updatevar = &fb_update_var;
-        fb_info.flags = FBINFO_FLAG_DEFAULT;
-        do_fb_set_var(&atafb_predefined[default_par-1], 1);
-        strcat(fb_info.modename, fb_var_names[default_par-1][0]);
-
-        atafb_get_var(&disp.var, -1, &fb_info);
-        atafb_set_disp(-1, &fb_info);
-        do_install_cmap(0, &fb_info);
-
-        if (register_framebuffer(&fb_info) < 0) {
-#ifdef ATAFB_EXT
-                if (external_addr) {
-                        iounmap(external_addr);
-                        external_addr = NULL;
-                }
-                if (external_vgaiobase) {
-                        iounmap((void*)external_vgaiobase);
-                        external_vgaiobase = 0;
-                }
-#endif
-                return -EINVAL;
-        }
-
-        printk("Determined %dx%d, depth %d\n",
-               disp.var.xres, disp.var.yres, disp.var.bits_per_pixel);
-        if ((disp.var.xres != disp.var.xres_virtual) ||
-            (disp.var.yres != disp.var.yres_virtual))
-           printk("   virtual %dx%d\n",
-                          disp.var.xres_virtual, disp.var.yres_virtual);
-        printk("fb%d: %s frame buffer device, using %dK of video memory\n",
-               fb_info.node, fb_info.modename, screen_len>>10);
-
-        /* TODO: This driver cannot be unloaded yet */
-        return 0;
+                default_mem_req = min_mem;
 }
 
-
 #ifdef ATAFB_EXT
 static void __init atafb_setup_ext(char *spec)
 {
-        int             xres, xres_virtual, yres, depth, planes;
+        int xres, xres_virtual, yres, depth, planes;
         unsigned long addr, len;
         char *p;
 
@@ -2848,27 +2842,31 @@ static void __init atafb_setup_ext(char *spec)
          *
          * Even xres_virtual is available, we neither support panning nor hw-scrolling!
          */
-        if (!(p = strsep(&spec, ";")) || !*p)
-            return;
+        p = strsep(&spec, ";");
+        if (!p || !*p)
+                return;
         xres_virtual = xres = simple_strtoul(p, NULL, 10);
         if (xres <= 0)
-            return;
+                return;
 
-        if (!(p = strsep(&spec, ";")) || !*p)
-            return;
+        p = strsep(&spec, ";");
+        if (!p || !*p)
+                return;
         yres = simple_strtoul(p, NULL, 10);
         if (yres <= 0)
-            return;
+                return;
 
-        if (!(p = strsep(&spec, ";")) || !*p)
-            return;
+        p = strsep(&spec, ";");
+        if (!p || !*p)
+                return;
         depth = simple_strtoul(p, NULL, 10);
         if (depth != 1 && depth != 2 && depth != 4 && depth != 8 &&
-                depth != 16 && depth != 24)
-            return;
+            depth != 16 && depth != 24)
+                return;
 
-        if (!(p = strsep(&spec, ";")) || !*p)
-            return;
+        p = strsep(&spec, ";");
+        if (!p || !*p)
+                return;
         if (*p == 'i')
                 planes = FB_TYPE_INTERLEAVED_PLANES;
         else if (*p == 'p')
@@ -2876,25 +2874,27 @@ static void __init atafb_setup_ext(char *spec)
         else if (*p == 'n')
                 planes = FB_TYPE_PLANES;
         else if (*p == 't')
-                planes = -1; /* true color */
+                planes = -1;            /* true color */
         else
                 return;
 
-
-        if (!(p = strsep(&spec, ";")) || !*p)
+        p = strsep(&spec, ";");
+        if (!p || !*p)
                 return;
         addr = simple_strtoul(p, NULL, 0);
 
-        if (!(p = strsep(&spec, ";")) || !*p)
-                len = xres*yres*depth/8;
+        p = strsep(&spec, ";");
+        if (!p || !*p)
+                len = xres * yres * depth / 8;
         else
                 len = simple_strtoul(p, NULL, 0);
 
-        if ((p = strsep(&spec, ";")) && *p) {
-                external_vgaiobase=simple_strtoul(p, NULL, 0);
-        }
+        p = strsep(&spec, ";");
+        if (p && *p)
+                external_vgaiobase = simple_strtoul(p, NULL, 0);
 
-        if ((p = strsep(&spec, ";")) && *p) {
+        p = strsep(&spec, ";");
+        if (p && *p) {
                 external_bitspercol = simple_strtoul(p, NULL, 0);
                 if (external_bitspercol > 8)
                         external_bitspercol = 8;
@@ -2902,59 +2902,61 @@ static void __init atafb_setup_ext(char *spec)
                         external_bitspercol = 1;
         }
 
-        if ((p = strsep(&spec, ";")) && *p) {
+        p = strsep(&spec, ";");
+        if (p && *p) {
                 if (!strcmp(p, "vga"))
                         external_card_type = IS_VGA;
                 if (!strcmp(p, "mv300"))
                         external_card_type = IS_MV300;
         }
 
-        if ((p = strsep(&spec, ";")) && *p) {
+        p = strsep(&spec, ";");
+        if (p && *p) {
                 xres_virtual = simple_strtoul(p, NULL, 10);
                 if (xres_virtual < xres)
                         xres_virtual = xres;
-                if (xres_virtual*yres*depth/8 > len)
-                        len=xres_virtual*yres*depth/8;
+                if (xres_virtual * yres * depth / 8 > len)
+                        len = xres_virtual * yres * depth / 8;
         }
 
-        external_xres  = xres;
-        external_xres_virtual  = xres_virtual;
-        external_yres  = yres;
+        external_xres = xres;
+        external_xres_virtual = xres_virtual;
+        external_yres = yres;
         external_depth = depth;
         external_pmode = planes;
-        external_addr  = (void *)addr;
-        external_len   = len;
-
-        if (external_card_type == IS_MV300)
-          switch (external_depth) {
-            case 1:
-              MV300_reg = MV300_reg_1bit;
-              break;
-            case 4:
-              MV300_reg = MV300_reg_4bit;
-              break;
-            case 8:
-              MV300_reg = MV300_reg_8bit;
-              break;
-            }
+        external_addr = (void *)addr;
+        external_len = len;
+
+        if (external_card_type == IS_MV300) {
+                switch (external_depth) {
+                case 1:
+                        MV300_reg = MV300_reg_1bit;
+                        break;
+                case 4:
+                        MV300_reg = MV300_reg_4bit;
+                        break;
+                case 8:
+                        MV300_reg = MV300_reg_8bit;
+                        break;
+                }
+        }
 }
 #endif /* ATAFB_EXT */
 
-
 static void __init atafb_setup_int(char *spec)
 {
         /* Format to config extended internal video hardware like OverScan:
-        "internal:<xres>;<yres>;<xres_max>;<yres_max>;<offset>"
-        Explanation:
-        <xres>: x-resolution 
-        <yres>: y-resolution
-        The following are only needed if you have an overscan which
-        needs a black border:
-        <xres_max>: max. length of a line in pixels your OverScan hardware would allow
-        <yres_max>: max. number of lines your OverScan hardware would allow
-        <offset>: Offset from physical beginning to visible beginning
-                  of screen in bytes
-        */
+         * "internal:<xres>;<yres>;<xres_max>;<yres_max>;<offset>"
+         * Explanation:
+         * <xres>: x-resolution
+         * <yres>: y-resolution
+         * The following are only needed if you have an overscan which
+         * needs a black border:
+         * <xres_max>: max. length of a line in pixels your OverScan hardware would allow
+         * <yres_max>: max. number of lines your OverScan hardware would allow
+         * <offset>: Offset from physical beginning to visible beginning
+         *        of screen in bytes
+         */
         int xres;
         char *p;
 
@@ -2963,23 +2965,19 @@ static void __init atafb_setup_int(char *spec)
         xres = simple_strtoul(p, NULL, 10);
         if (!(p = strsep(&spec, ";")) || !*p)
                 return;
-        sttt_xres=xres;
-        tt_yres=st_yres=simple_strtoul(p, NULL, 10);
-        if ((p=strsep(&spec, ";")) && *p) {
-                sttt_xres_virtual=simple_strtoul(p, NULL, 10);
-        }
-        if ((p=strsep(&spec, ";")) && *p) {
-                sttt_yres_virtual=simple_strtoul(p, NULL, 0);
-        }
-        if ((p=strsep(&spec, ";")) && *p) {
-                ovsc_offset=simple_strtoul(p, NULL, 0);
-        }
+        sttt_xres = xres;
+        tt_yres = st_yres = simple_strtoul(p, NULL, 10);
+        if ((p = strsep(&spec, ";")) && *p)
+                sttt_xres_virtual = simple_strtoul(p, NULL, 10);
+        if ((p = strsep(&spec, ";")) && *p)
+                sttt_yres_virtual = simple_strtoul(p, NULL, 0);
+        if ((p = strsep(&spec, ";")) && *p)
+                ovsc_offset = simple_strtoul(p, NULL, 0);
 
         if (ovsc_offset || (sttt_yres_virtual != st_yres))
-                use_hwscroll=0;
+                use_hwscroll = 0;
 }
 
-
 #ifdef ATAFB_FALCON
 static void __init atafb_setup_mcap(char *spec)
 {
@@ -3018,7 +3016,6 @@ static void __init atafb_setup_mcap(char *spec)
 }
 #endif /* ATAFB_FALCON */
 
-
 static void __init atafb_setup_user(char *spec)
 {
         /* Format of user defined video mode is: <xres>;<yres>;<depth>
@@ -3026,81 +3023,257 @@ static void __init atafb_setup_user(char *spec)
         char *p;
         int xres, yres, depth, temp;
 
-        if (!(p = strsep(&spec, ";")) || !*p)
+        p = strsep(&spec, ";");
+        if (!p || !*p)
                 return;
         xres = simple_strtoul(p, NULL, 10);
-        if (!(p = strsep(&spec, ";")) || !*p)
+        p = strsep(&spec, ";");
+        if (!p || !*p)
                 return;
         yres = simple_strtoul(p, NULL, 10);
-        if (!(p = strsep(&spec, "")) || !*p)
+        p = strsep(&spec, "");
+        if (!p || !*p)
                 return;
         depth = simple_strtoul(p, NULL, 10);
-        if ((temp=get_video_mode("user0"))) {
-                default_par=temp;
-                atafb_predefined[default_par-1].xres = xres;
-                atafb_predefined[default_par-1].yres = yres;
-                atafb_predefined[default_par-1].bits_per_pixel = depth;
+        temp = get_video_mode("user0");
+        if (temp) {
+                default_par = temp;
+                atafb_predefined[default_par - 1].xres = xres;
+                atafb_predefined[default_par - 1].yres = yres;
+                atafb_predefined[default_par - 1].bits_per_pixel = depth;
         }
 }
 
-int __init atafb_setup( char *options )
+int __init atafb_setup(char *options)
 {
-    char *this_opt;
-    int temp;
-
-    fb_info.fontname[0] = '\0';
+        char *this_opt;
+        int temp;
 
-    if (!options || !*options)
+        if (!options || !*options)
                 return 0;
-    
-    while ((this_opt = strsep(&options, ",")) != NULL) {         
-        if (!*this_opt) continue;
-        if ((temp=get_video_mode(this_opt)))
-                default_par=temp;
-        else if (! strcmp(this_opt, "inverse"))
-                inverse=1;
-        else if (!strncmp(this_opt, "font:", 5))
-           strcpy(fb_info.fontname, this_opt+5);
-        else if (! strncmp(this_opt, "hwscroll_",9)) {
-                hwscroll=simple_strtoul(this_opt+9, NULL, 10);
-                if (hwscroll < 0)
-                        hwscroll = 0;
-                if (hwscroll > 200)
-                        hwscroll = 200;
-        }
+
+        while ((this_opt = strsep(&options, ",")) != NULL) {
+                if (!*this_opt)
+                        continue;
+                if ((temp = get_video_mode(this_opt))) {
+                        default_par = temp;
+                        mode_option = this_opt;
+                } else if (!strcmp(this_opt, "inverse"))
+                        inverse = 1;
+                else if (!strncmp(this_opt, "hwscroll_", 9)) {
+                        hwscroll = simple_strtoul(this_opt + 9, NULL, 10);
+                        if (hwscroll < 0)
+                                hwscroll = 0;
+                        if (hwscroll > 200)
+                                hwscroll = 200;
+                }
 #ifdef ATAFB_EXT
-        else if (!strcmp(this_opt,"mv300")) {
-                external_bitspercol = 8;
-                external_card_type = IS_MV300;
+                else if (!strcmp(this_opt, "mv300")) {
+                        external_bitspercol = 8;
+                        external_card_type = IS_MV300;
+                } else if (!strncmp(this_opt, "external:", 9))
+                        atafb_setup_ext(this_opt + 9);
+#endif
+                else if (!strncmp(this_opt, "internal:", 9))
+                        atafb_setup_int(this_opt + 9);
+#ifdef ATAFB_FALCON
+                else if (!strncmp(this_opt, "eclock:", 7)) {
+                        fext.f = simple_strtoul(this_opt + 7, NULL, 10);
+                        /* external pixelclock in kHz --> ps */
+                        fext.t = 1000000000 / fext.f;
+                        fext.f *= 1000;
+                } else if (!strncmp(this_opt, "monitorcap:", 11))
+                        atafb_setup_mcap(this_opt + 11);
+#endif
+                else if (!strcmp(this_opt, "keep"))
+                        DontCalcRes = 1;
+                else if (!strncmp(this_opt, "R", 1))
+                        atafb_setup_user(this_opt + 1);
         }
-        else if (!strncmp(this_opt,"external:",9))
-                atafb_setup_ext(this_opt+9);
+        return 0;
+}
+
+int __init atafb_init(void)
+{
+        int pad;
+        int detected_mode;
+        unsigned int defmode = 0;
+        unsigned long mem_req;
+
+#ifndef MODULE
+        char *option = NULL;
+
+        if (fb_get_options("atafb", &option))
+                return -ENODEV;
+        atafb_setup(option);
+#endif
+        printk("atafb_init: start\n");
+
+        if (!MACH_IS_ATARI)
+                return -ENXIO;
+
+        do {
+#ifdef ATAFB_EXT
+                if (external_addr) {
+                        printk("atafb_init: initializing external hw\n");
+                        fbhw = &ext_switch;
+                        atafb_ops.fb_setcolreg = &ext_setcolreg;
+                        defmode = DEFMODE_EXT;
+                        break;
+                }
+#endif
+#ifdef ATAFB_TT
+                if (ATARIHW_PRESENT(TT_SHIFTER)) {
+                        printk("atafb_init: initializing TT hw\n");
+                        fbhw = &tt_switch;
+                        atafb_ops.fb_setcolreg = &tt_setcolreg;
+                        defmode = DEFMODE_TT;
+                        break;
+                }
 #endif
-        else if (!strncmp(this_opt,"internal:",9))
-                atafb_setup_int(this_opt+9);
 #ifdef ATAFB_FALCON
-        else if (!strncmp(this_opt, "eclock:", 7)) {
-                fext.f = simple_strtoul(this_opt+7, NULL, 10);
-                /* external pixelclock in kHz --> ps */
-                fext.t = 1000000000/fext.f;
-                fext.f *= 1000;
+                if (ATARIHW_PRESENT(VIDEL_SHIFTER)) {
+                        printk("atafb_init: initializing Falcon hw\n");
+                        fbhw = &falcon_switch;
+                        atafb_ops.fb_setcolreg = &falcon_setcolreg;
+                        request_irq(IRQ_AUTO_4, falcon_vbl_switcher, IRQ_TYPE_PRIO,
+                                    "framebuffer/modeswitch", falcon_vbl_switcher);
+                        defmode = DEFMODE_F30;
+                        break;
+                }
+#endif
+#ifdef ATAFB_STE
+                if (ATARIHW_PRESENT(STND_SHIFTER) ||
+                    ATARIHW_PRESENT(EXTD_SHIFTER)) {
+                        printk("atafb_init: initializing ST/E hw\n");
+                        fbhw = &st_switch;
+                        atafb_ops.fb_setcolreg = &stste_setcolreg;
+                        defmode = DEFMODE_STE;
+                        break;
+                }
+                fbhw = &st_switch;
+                atafb_ops.fb_setcolreg = &stste_setcolreg;
+                printk("Cannot determine video hardware; defaulting to ST(e)\n");
+#else /* ATAFB_STE */
+                /* no default driver included */
+                /* Nobody will ever see this message :-) */
+                panic("Cannot initialize video hardware");
+#endif
+        } while (0);
+
+        /* Multisync monitor capabilities */
+        /* Atari-TOS defaults if no boot option present */
+        if (fb_info.monspecs.hfmin == 0) {
+                fb_info.monspecs.hfmin = 31000;
+                fb_info.monspecs.hfmax = 32000;
+                fb_info.monspecs.vfmin = 58;
+                fb_info.monspecs.vfmax = 62;
         }
-        else if (!strncmp(this_opt, "monitorcap:", 11))
-                atafb_setup_mcap(this_opt+11);
+
+        detected_mode = fbhw->detect();
+        check_default_par(detected_mode);
+#ifdef ATAFB_EXT
+        if (!external_addr) {
+#endif /* ATAFB_EXT */
+                mem_req = default_mem_req + ovsc_offset + ovsc_addlen;
+                mem_req = PAGE_ALIGN(mem_req) + PAGE_SIZE;
+                screen_base = atari_stram_alloc(mem_req, "atafb");
+                if (!screen_base)
+                        panic("Cannot allocate screen memory");
+                memset(screen_base, 0, mem_req);
+                pad = -(unsigned long)screen_base & (PAGE_SIZE - 1);
+                screen_base += pad;
+                real_screen_base = screen_base + ovsc_offset;
+                screen_len = (mem_req - pad - ovsc_offset) & PAGE_MASK;
+                st_ovsc_switch();
+                if (CPU_IS_040_OR_060) {
+                        /* On a '040+, the cache mode of video RAM must be set to
+                         * write-through also for internal video hardware! */
+                        cache_push(virt_to_phys(screen_base), screen_len);
+                        kernel_set_cachemode(screen_base, screen_len,
+                                             IOMAP_WRITETHROUGH);
+                }
+                printk("atafb: screen_base %p real_screen_base %p screen_len %d\n",
+                        screen_base, real_screen_base, screen_len);
+#ifdef ATAFB_EXT
+        } else {
+                /* Map the video memory (physical address given) to somewhere
+                 * in the kernel address space.
+                 */
+                external_addr = ioremap_writethrough((unsigned long)external_addr,
+                                                     external_len);
+                if (external_vgaiobase)
+                        external_vgaiobase =
+                          (unsigned long)ioremap(external_vgaiobase, 0x10000);
+                screen_base =
+                real_screen_base = external_addr;
+                screen_len = external_len & PAGE_MASK;
+                memset (screen_base, 0, external_len);
+        }
+#endif /* ATAFB_EXT */
+
+//      strcpy(fb_info.mode->name, "Atari Builtin ");
+        fb_info.fbops = &atafb_ops;
+        // try to set default (detected; requested) var
+        do_fb_set_var(&atafb_predefined[default_par - 1], 1);
+        // reads hw state into current par, which may not be sane yet
+        ata_get_par(&current_par);
+        fb_info.par = &current_par;
+        // tries to read from HW which may not be initialized yet
+        // so set sane var first, then call atafb_set_par
+        atafb_get_var(&fb_info.var, &fb_info);
+        fb_info.flags = FBINFO_FLAG_DEFAULT;
+
+        if (!fb_find_mode(&fb_info.var, &fb_info, mode_option, atafb_modedb,
+                          NUM_TOTAL_MODES, &atafb_modedb[defmode],
+                          fb_info.var.bits_per_pixel)) {
+                return -EINVAL;
+        }
+
+        atafb_set_disp(&fb_info);
+
+        fb_alloc_cmap(&(fb_info.cmap), 1 << fb_info.var.bits_per_pixel, 0);
+
+
+        printk("Determined %dx%d, depth %d\n",
+               fb_info.var.xres, fb_info.var.yres, fb_info.var.bits_per_pixel);
+        if ((fb_info.var.xres != fb_info.var.xres_virtual) ||
+            (fb_info.var.yres != fb_info.var.yres_virtual))
+                printk("   virtual %dx%d\n", fb_info.var.xres_virtual,
+                       fb_info.var.yres_virtual);
+
+        if (register_framebuffer(&fb_info) < 0) {
+#ifdef ATAFB_EXT
+                if (external_addr) {
+                        iounmap(external_addr);
+                        external_addr = NULL;
+                }
+                if (external_vgaiobase) {
+                        iounmap((void*)external_vgaiobase);
+                        external_vgaiobase = 0;
+                }
 #endif
-        else if (!strcmp(this_opt, "keep"))
-                DontCalcRes = 1;
-        else if (!strncmp(this_opt, "R", 1))
-                atafb_setup_user(this_opt+1);
-    }
-    return 0;
+                return -EINVAL;
+        }
+
+        // FIXME: mode needs setting!
+        //printk("fb%d: %s frame buffer device, using %dK of video memory\n",
+        //       fb_info.node, fb_info.mode->name, screen_len>>10);
+        printk("fb%d: frame buffer device, using %dK of video memory\n",
+               fb_info.node, screen_len >> 10);
+
+        /* TODO: This driver cannot be unloaded yet */
+        return 0;
 }
 
+module_init(atafb_init);
+
 #ifdef MODULE
 MODULE_LICENSE("GPL");
 
-int init_module(void)
+int cleanup_module(void)
 {
-        return atafb_init();
+        unregister_framebuffer(&fb_info);
+        return atafb_deinit();
 }
 #endif /* MODULE */