m68k: Atari fb revival
authorMichael Schmitz <schmitz@opal.biophys.uni-duesseldorf.de>
Tue, 1 May 2007 20:32:39 +0000 (22:32 +0200)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Sat, 5 May 2007 00:59:05 +0000 (17:59 -0700)
Update the atari fb to 2.6 by Michael Schmitz,
Reformatting and rewrite of bit plane functions by Roman Zippel,
A few more fixes by Geert Uytterhoeven.

Signed-off-by: Michael Schmitz <schmitz@debian.org>
Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
drivers/video/Kconfig
drivers/video/Makefile
drivers/video/atafb.c
drivers/video/atafb.h [new file with mode: 0644]
drivers/video/atafb_iplan2p2.c [new file with mode: 0644]
drivers/video/atafb_iplan2p4.c [new file with mode: 0644]
drivers/video/atafb_iplan2p8.c [new file with mode: 0644]
drivers/video/atafb_mfb.c [new file with mode: 0644]
drivers/video/atafb_utils.h [new file with mode: 0644]

index b1cb72c3780fe562a7a382bc339c62308f978a03..d18b51f989c9f7e0c692804a17694df398d3d243 100644 (file)
@@ -389,7 +389,10 @@ config FB_ARC
 
 config FB_ATARI
        bool "Atari native chipset support"
 
 config FB_ATARI
        bool "Atari native chipset support"
-       depends on (FB = y) && ATARI && BROKEN
+       depends on (FB = y) && ATARI
+       select FB_CFB_FILLRECT
+       select FB_CFB_COPYAREA
+       select FB_CFB_IMAGEBLIT
        help
          This is the frame buffer device driver for the builtin graphics
          chipset found in Ataris.
        help
          This is the frame buffer device driver for the builtin graphics
          chipset found in Ataris.
index 760305c8a8416736cb61d005bccf5459c8728e4f..869351785ee8deda91ae8940272db60eefca99f0 100644 (file)
@@ -63,7 +63,8 @@ obj-$(CONFIG_FB_TCX)              += tcx.o sbuslib.o
 obj-$(CONFIG_FB_LEO)              += leo.o sbuslib.o
 obj-$(CONFIG_FB_SGIVW)            += sgivwfb.o
 obj-$(CONFIG_FB_ACORN)            += acornfb.o
 obj-$(CONFIG_FB_LEO)              += leo.o sbuslib.o
 obj-$(CONFIG_FB_SGIVW)            += sgivwfb.o
 obj-$(CONFIG_FB_ACORN)            += acornfb.o
-obj-$(CONFIG_FB_ATARI)            += atafb.o
+obj-$(CONFIG_FB_ATARI)            += atafb.o c2p.o atafb_mfb.o \
+                                     atafb_iplan2p2.o atafb_iplan2p4.o atafb_iplan2p8.o
 obj-$(CONFIG_FB_MAC)              += macfb.o
 obj-$(CONFIG_FB_HGA)              += hgafb.o
 obj-$(CONFIG_FB_IGA)              += igafb.o
 obj-$(CONFIG_FB_MAC)              += macfb.o
 obj-$(CONFIG_FB_HGA)              += hgafb.o
 obj-$(CONFIG_FB_IGA)              += igafb.o
index bffe2b946344b37881f0fed387965562b357724d..0038a0541c7eac5ec30e1ae4bf8ae0b61e8d83c4 100644 (file)
@@ -2,7 +2,7 @@
  * linux/drivers/video/atafb.c -- Atari builtin chipset frame buffer device
  *
  *  Copyright (C) 1994 Martin Schaller & Roman Hodek
  * 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.
  * 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.
 #include <linux/fb.h>
 #include <asm/atarikb.h>
 
 #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
 
 #define SWITCH_ACIA 0x01               /* modes for switch on OverScan */
 #define SWITCH_SND6 0x40
 
 #define up(x, r) (((x) + (r) - 1) & ~((r)-1))
 
 
 #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 unsigned long default_mem_req=0;
+static int default_par;                /* default resolution (0=none) */
 
 
-static int hwscroll=-1;
+static unsigned long default_mem_req;
+
+static int hwscroll = -1;
 
 static int use_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;
 
 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 {
 #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)  */
 /* 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
 
 #ifdef ATAFB_FALCON
 #define HHT hw.falcon.hht
@@ -163,83 +183,84 @@ static int DontCalcRes = 0;
 #define VMO_PREMASK            0x0c
 #endif
 
 #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 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 mono_moni=0;
+static int current_par_valid;
 
 
-static struct display disp;
+static int mono_moni;
 
 
 #ifdef ATAFB_EXT
 
 
 #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;
 
 /*
 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;
 
 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 */
 
 
 #endif /* ATAFB_EXT */
 
 
-static int inverse=0;
+static int inverse;
 
 extern int fontheight_8x8;
 extern int fontwidth_8x8;
 
 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[];
 
 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.
  *
 /* ++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.
  *   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.
  *   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.
  *   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.
  *
  *   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.
  *   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.
  *   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'.
  *   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.
  *
  *
  * 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:
  *   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 {
  */
 
 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);
        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;
 
 } *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[] = {
 
 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,
        autodetect_names,
        stlow_names,
        stmid_names,
@@ -353,18 +432,17 @@ static char **fb_var_names[] = {
        falh2_names,
        falh16_names,
        NULL
        falh2_names,
        falh16_names,
        NULL
-       /* ,NULL */ /* this causes a sigsegv on my gcc-2.5.8 */
 };
 
 static struct fb_var_screeninfo atafb_predefined[] = {
 };
 
 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 },
          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 },
          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 },
 };
 
          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
 
 
 #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;
 
 {
        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->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) {
        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)
                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;
 }
 
        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) {
        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;
                        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) {
        } 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;
                                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 || 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;
+                       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 {
-                               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;
                                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;
                        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)
                }
        }
        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)
        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
        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)
        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;
 }
 
        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));
 {
        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)
 
        if (par->hw.tt.sync & 1)
-               var->sync=0;
+               var->sync = 0;
        else
        else
-               var->sync=FB_SYNC_EXT;
+               var->sync = FB_SYNC_EXT;
 
        switch (par->hw.tt.mode & TT_SHIFTER_MODEMASK) {
        case TT_SHIFTER_STLOW:
 
        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:
                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:
                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:
                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:
                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:
                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;
                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
        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 = 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)
        if (screen_base)
-               var->yoffset=(par->screen_base - screen_base)/linelen;
+               var->yoffset = (par->screen_base - screen_base) / linelen;
        else
        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;
 }
 
        return 0;
 }
 
-
-static void tt_get_par( struct atafb_par *par )
+static void tt_get_par(struct atafb_par *par)
 {
        unsigned long addr;
 {
        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);
 }
 
        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);
 }
 
        /* 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;
 {
        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_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;
 }
 
                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
 
        /* 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...
         */
         * 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;
                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;
 
        }
        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 */
        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 */
        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] */
 
 /* 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 */
 
 /* 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];
 
 #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)
 {
 
 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;
 {
        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;
                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? */
                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;
 }
 
        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;
 {
        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 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 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.
 
 /*
        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
        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.
 
        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
 
        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.
 */
 
        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 (!xres || !yres || !bpp)
                return -EINVAL;
 
-       if (mon_type == F_MON_SM && bpp != 1) {
+       if (mon_type == F_MON_SM && bpp != 1)
                return -EINVAL;
                return -EINVAL;
-       }
-       else if (bpp <= 1) {
+
+       if (bpp <= 1) {
                bpp = 1;
                par->hw.falcon.f_shift = 0x400;
                par->hw.falcon.st_shift = 0x200;
                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;
                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;
                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;
                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];
                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 ||
                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 */
                        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 */
                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
 
        /* 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 */
                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;
 #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;
                        }
                }
                                vsync_len *= 2;
                        }
                }
-       }
-       else
-       {       /* F_MON_VGA */
+       } else {                        /* F_MON_VGA */
                if (bpp == 16)
                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;
                /* 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;
                            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;
                                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;
                                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;
                        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;
                        /* 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;
                                }
                                        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;
                                }
                                        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;
                                }
                                        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;
                                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;
                                /* 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)
                        }
                }
                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 */
        }
        /* 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.
         */
         * 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)
        /* 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 */
        /* 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;
 
        /*********************
        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 */
        /* 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;
 
        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;
                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)
                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;
        }
 
                        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 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;*/
 
        /* 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;
        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 */
        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
                /* 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;
        par->HSS = par->HHT + 2 - plen * hsync_len / prescale;
        if (par->HSS < par->HBB)
                par->HSS = par->HBB;
-       }
+}
 
        /*  check hor. frequency */
 
        /*  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;
                /* ++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;
        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->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++;
        /* 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);
        /* 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;
                /* 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;
                /* 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;
                /* 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;
                     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;
                /* 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;
                        ;
                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;
                /* 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;
                     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;
 
                return -EINVAL;
 
-  set_screen_base:
+set_screen_base:
        linelen = xres_virtual * bpp / 8;
        if (yres_virtual * linelen > screen_len && screen_len)
                return -EINVAL;
        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;
 
        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;
 }
 
        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;
 {
 /* !!! 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->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)
        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;
                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
        /* 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;
 
        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)
         */
         * 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;
                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;
                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;
                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->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.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
 
        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;
                        var->yres_virtual = screen_len / linelen;
-       }
-       else {
+       } else {
                if (hwscroll < 0)
                        var->yres_virtual = 2 * var->yres;
                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);
 
        /* 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;
        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)
                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) -
 
        /* 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 */
                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->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;
        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;
                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->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
        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;
 }
 
        return 0;
 }
 
-
-static int f_change_mode = 0;
+static int f_change_mode;
 static struct falcon_hw f_new_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;
 {
        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 */
        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->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;
 
 {
        f_change_mode = 0;
 
@@ -1519,8 +1631,7 @@ static void falcon_set_par( struct atafb_par *par )
        f_change_mode = 1;
 }
 
        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;
 
 {
        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 */
 
                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. */
                        /* Turn off external clocks. Read sets all output bits to 1. */
-                       *(volatile unsigned short*)0xffff9202;
+                       *(volatile unsigned short *)0xffff9202;
                }
                shifter.syncmode = hw->sync;
 
                }
                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.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) {
                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:
                        /* 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
                         * 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;
                         * with Falcon palette.
                         */
                        videl.st_shift = 0;
@@ -1580,12 +1689,13 @@ static irqreturn_t falcon_vbl_switcher( int irq, void *dummy )
        return IRQ_HANDLED;
 }
 
        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 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);
 
        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 *
                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 +
        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)
        if (fbhw->set_screen_base)
-               fbhw->set_screen_base (par->screen_base);
+               fbhw->set_screen_base(par->screen_base);
        else
        else
-               return -EINVAL; /* shouldn't happen */
+               return -EINVAL;         /* shouldn't happen */
        f_pan_display = 1;
        return 0;
 }
 
        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;
 {
        if (regno > 255)
                return 1;
@@ -1655,13 +1744,12 @@ static int falcon_setcolreg( unsigned regno, unsigned red,
        return 0;
 }
 
        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 */
        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;
 }
 
        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 */
 {
        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;
        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 */
        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;
                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
 
 
 #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;
 
 {
        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->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;
 }
 
        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;
        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) {
        } 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;
                                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;
                                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)
                        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)
        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
        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)
        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;
        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;
 }
 
        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));
 {
        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.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))
 
        if (!(par->hw.st.sync & 1))
-               var->sync=0;
+               var->sync = 0;
        else
        else
-               var->sync=FB_SYNC_EXT;
+               var->sync = FB_SYNC_EXT;
 
        switch (par->hw.st.mode & 3) {
        case ST_LOW:
 
        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:
                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:
                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;
                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
        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;
                        var->yres_virtual = screen_len / linelen;
-       }
-       else {
+       } else {
                if (hwscroll < 0)
                        var->yres_virtual = 2 * var->yres;
                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)
        if (screen_base)
-               var->yoffset=(par->screen_base - screen_base)/linelen;
+               var->yoffset = (par->screen_base - screen_base) / linelen;
        else
        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;
 }
 
        return 0;
 }
 
-
-static void stste_get_par( struct atafb_par *par )
+static void stste_get_par(struct atafb_par *par)
 {
        unsigned long addr;
 {
        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))
        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);
 }
 
        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);
 }
 
        /* 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;
 {
        if (regno > 15)
                return 1;
@@ -1988,10 +2032,9 @@ static int stste_setcolreg(unsigned regno, unsigned red,
        return 0;
 }
 
        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
 
        /* 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;
         */
        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;
 
        }
        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;
 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 */
        /* 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))
        if (ATARIHW_PRESENT(EXTD_SHIFTER))
-               shifter.bas_lo=(unsigned char)  (addr & 0x0000ff);
+               shifter.bas_lo = (unsigned char)(addr & 0x0000ff);
 }
 
 #endif /* ATAFB_STE */
 }
 
 #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)
 {
 /* 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;
        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
 
 }
 
 /* ------------------- 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) {
        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) ?
                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) {
                /* 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;
                        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;
                        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;
                        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;
                }
        }
                        break;
                }
        }
@@ -2134,137 +2173,112 @@ static int ext_encode_fix( struct fb_fix_screeninfo *fix,
        return 0;
 }
 
        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];
 {
        struct fb_var_screeninfo *myvar = &atafb_predefined[0];
-       
+
        if (var->bits_per_pixel > myvar->bits_per_pixel ||
        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;
 }
 
                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));
 {
        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);
                        (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->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;
 }
 
        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;
 }
 
 {
        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) \
 {
 }
 
 #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 INB(port) \
        (*((unsigned volatile char *) ((port)+external_vgaiobase)))
-#define DACDelay                               \
+#define DACDelay                               \
        do {                                    \
        do {                                    \
-               unsigned char tmp=INB(0x3da);   \
-               tmp=INB(0x3da);                 \
+               unsigned char tmp = INB(0x3da); \
+               tmp = INB(0x3da);                       \
        } while (0)
 
        } 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)
-               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 )
-
-{      unsigned char colmask = (1 << external_bitspercol) - 1;
+       unsigned char colmask = (1 << external_bitspercol) - 1;
 
 
-       if (! external_vgaiobase)
+       if (!external_vgaiobase)
                return 1;
 
                return 1;
 
-       ext_color[regno].red = red;
-       ext_color[regno].green = green;
-       ext_color[regno].blue = blue;
-
        switch (external_card_type) {
        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;
-         }
-}
-       
+       case IS_VGA:
+               OUTB(0x3c8, regno);
+               DACDelay;
+               OUTB(0x3c9, red & colmask);
+               DACDelay;
+               OUTB(0x3c9, green & colmask);
+               DACDelay;
+               OUTB(0x3c9, blue & colmask);
+               DACDelay;
+               return 0;
 
 
-static int ext_detect( void )
+       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)
 {
        struct fb_var_screeninfo *myvar = &atafb_predefined[0];
        struct atafb_par dummy_par;
 {
        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;
 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 */
        /* 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 ||
        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 +
                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;
 }
 
        return 0;
 }
 
-
 /* ------------ Interfaces to hardware functions ------------ */
 
 /* ------------ Interfaces to hardware functions ------------ */
 
-
 #ifdef ATAFB_TT
 static struct fb_hwswitch tt_switch = {
 #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 = {
 };
 #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 = {
 };
 #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 = {
 };
 #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
 
 };
 #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);
 }
 
        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);
 {
        fbhw->set_par(par);
-       current_par=*par;
-       current_par_valid=1;
+       current_par = *par;
+       current_par_valid = 1;
 }
 
 
 }
 
 
-
 /* =========================================================== */
 /* ============== Hardware Independent Functions ============= */
 /* =========================================================== */
 
 /* =========================================================== */
 /* ============== Hardware Independent Functions ============= */
 /* =========================================================== */
 
-
 /* used for hardware scrolling */
 
 /* 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;
        struct atafb_par par;
-       if ((err=fbhw->decode_var(var, &par)))
+
+       err = fbhw->decode_var(var, &par);
+       if (err)
                return err;
                return err;
-       activate=var->activate;
+       activate = var->activate;
        if (((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive)
        if (((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive)
-               atafb_set_par(&par);
+               ata_set_par(&par);
        fbhw->encode_var(var, &par);
        fbhw->encode_var(var, &par);
-       var->activate=activate;
+       var->activate = activate;
        return 0;
 }
 
        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;
 {
        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);
 }
        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;
 {
        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;
 }
 
        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;
                        break;
-#endif
-#ifdef FBCON_HAS_IPLAN2P4
-                   case 4:
-                       display->dispsw = &fbcon_iplan2p4;
+               case 4:
+                       // display->dispsw = &fbcon_iplan2p4;
                        break;
                        break;
-#endif
-#ifdef FBCON_HAS_IPLAN2P8
-                   case 8:
-                       display->dispsw = &fbcon_iplan2p8;
+               case 8:
+                       // display->dispsw = &fbcon_iplan2p8;
                        break;
                        break;
-#endif
                }
                break;
                }
                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
 #ifdef FBCON_HAS_MFB
-                   case 1:
-                       display->dispsw = &fbcon_mfb;
+               case 1:
+                       // display->dispsw = &fbcon_mfb;
                        break;
 #endif
 #ifdef FBCON_HAS_CFB8
                        break;
 #endif
 #ifdef FBCON_HAS_CFB8
-                   case 8:
-                       display->dispsw = &fbcon_cfb8;
+               case 8:
+                       // display->dispsw = &fbcon_cfb8;
                        break;
 #endif
 #ifdef FBCON_HAS_CFB16
                        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
                }
                        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
 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;
 }
 
        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
        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 (con == info->currcon) {
-               if (fbhw->pan_display) {
-                       if ((err = fbhw->pan_display(var, &current_par)))
-                               return err;
+       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);
+
+       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
 }
 
 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;
                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
        }
                return 0;
 #endif
        }
@@ -2598,42 +2710,82 @@ atafb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
  * 3 = suspend hsync
  * 4 = off
  */
  * 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) {
 {
        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
        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;
 }
 
        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,
 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_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,
 };
 
        .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;
 {
        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) {
 
        /* 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;
                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 */
        }
        /* 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;
                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 that also failed, try some default modes... */
-       if (! default_par) {
+       if (!default_par) {
                /* try default1, default2... */
                /* 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");
                                panic("can't set default video mode");
-                       var=atafb_predefined[default_par-1];
+                       var = atafb_predefined[default_par - 1];
                        var.activate = FB_ACTIVATE_TEST;
                        var.activate = FB_ACTIVATE_TEST;
-                       if (! do_fb_set_var(&var,1))
+                       if (!do_fb_set_var(&var,1))
                                break;  /* ok */
                }
        }
                                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)
        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;
+               default_mem_req = min_mem;
 }
 
 }
 
-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;
-}
-
-
 #ifdef ATAFB_EXT
 static void __init atafb_setup_ext(char *spec)
 {
 #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;
 
        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!
         */
         *
         * 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)
        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)
        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 = 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')
        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')
        else if (*p == 'n')
                planes = FB_TYPE_PLANES;
        else if (*p == 't')
-               planes = -1; /* true color */
+               planes = -1;            /* true color */
        else
                return;
 
        else
                return;
 
-
-       if (!(p = strsep(&spec, ";")) || !*p)
+       p = strsep(&spec, ";");
+       if (!p || !*p)
                return;
        addr = simple_strtoul(p, NULL, 0);
 
                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);
 
        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;
                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;
        }
 
                        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 (!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;
                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_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 */
 
 }
 #endif /* ATAFB_EXT */
 
-
 static void __init atafb_setup_int(char *spec)
 {
        /* Format to config extended internal video hardware like OverScan:
 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;
 
        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;
        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))
 
        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)
 {
 #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 */
 
 }
 #endif /* ATAFB_FALCON */
 
-
 static void __init atafb_setup_user(char *spec)
 {
        /* Format of user defined video mode is: <xres>;<yres>;<depth>
 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;
 
        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);
                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);
                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);
                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;
                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
 #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
 #endif
-       else if (!strncmp(this_opt,"internal:",9))
-               atafb_setup_int(this_opt+9);
 #ifdef ATAFB_FALCON
 #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
 #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");
 
 #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 */
 }
 #endif /* MODULE */
diff --git a/drivers/video/atafb.h b/drivers/video/atafb.h
new file mode 100644 (file)
index 0000000..014e059
--- /dev/null
@@ -0,0 +1,36 @@
+#ifndef _VIDEO_ATAFB_H
+#define _VIDEO_ATAFB_H
+
+void atafb_mfb_copyarea(struct fb_info *info, u_long next_line, int sy, int sx, int dy,
+                       int dx, int height, int width);
+void atafb_mfb_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                       int sy, int sx, int height, int width);
+void atafb_mfb_linefill(struct fb_info *info, u_long next_line,
+                       int dy, int dx, u32 width,
+                       const u8 *data, u32 bgcolor, u32 fgcolor);
+
+void atafb_iplan2p2_copyarea(struct fb_info *info, u_long next_line, int sy, int sx, int dy,
+                            int dx, int height, int width);
+void atafb_iplan2p2_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                            int sy, int sx, int height, int width);
+void atafb_iplan2p2_linefill(struct fb_info *info, u_long next_line,
+                            int dy, int dx, u32 width,
+                            const u8 *data, u32 bgcolor, u32 fgcolor);
+
+void atafb_iplan2p4_copyarea(struct fb_info *info, u_long next_line, int sy, int sx, int dy,
+                            int dx, int height, int width);
+void atafb_iplan2p4_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                            int sy, int sx, int height, int width);
+void atafb_iplan2p4_linefill(struct fb_info *info, u_long next_line,
+                            int dy, int dx, u32 width,
+                            const u8 *data, u32 bgcolor, u32 fgcolor);
+
+void atafb_iplan2p8_copyarea(struct fb_info *info, u_long next_line, int sy, int sx, int dy,
+                            int dx, int height, int width);
+void atafb_iplan2p8_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                            int sy, int sx, int height, int width);
+void atafb_iplan2p8_linefill(struct fb_info *info, u_long next_line,
+                            int dy, int dx, u32 width,
+                            const u8 *data, u32 bgcolor, u32 fgcolor);
+
+#endif /* _VIDEO_ATAFB_H */
diff --git a/drivers/video/atafb_iplan2p2.c b/drivers/video/atafb_iplan2p2.c
new file mode 100644 (file)
index 0000000..8cc9c50
--- /dev/null
@@ -0,0 +1,293 @@
+/*
+ *  linux/drivers/video/iplan2p2.c -- Low level frame buffer operations for
+ *                                   interleaved bitplanes à la Atari (2
+ *                                   planes, 2 bytes interleave)
+ *
+ *     Created 5 Apr 1997 by Geert Uytterhoeven
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/fb.h>
+
+#include <asm/setup.h>
+
+#include "atafb.h"
+
+#define BPL    2
+#include "atafb_utils.h"
+
+void atafb_iplan2p2_copyarea(struct fb_info *info, u_long next_line,
+                            int sy, int sx, int dy, int dx,
+                            int height, int width)
+{
+       /*  bmove() has to distinguish two major cases: If both, source and
+        *  destination, start at even addresses or both are at odd
+        *  addresses, just the first odd and last even column (if present)
+        *  require special treatment (memmove_col()). The rest between
+        *  then can be copied by normal operations, because all adjacent
+        *  bytes are affected and are to be stored in the same order.
+        *    The pathological case is when the move should go from an odd
+        *  address to an even or vice versa. Since the bytes in the plane
+        *  words must be assembled in new order, it seems wisest to make
+        *  all movements by memmove_col().
+        */
+
+       u8 *src, *dst;
+       u32 *s, *d;
+       int w, l , i, j;
+       u_int colsize;
+       u_int upwards = (dy < sy) || (dy == sy && dx < sx);
+
+       colsize = height;
+       if (!((sx ^ dx) & 15)) {
+               /* odd->odd or even->even */
+
+               if (upwards) {
+                       src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
+                       if (sx & 15) {
+                               memmove32_col(dst, src, 0xff00ff, height, next_line - BPL * 2);
+                               src += BPL * 2;
+                               dst += BPL * 2;
+                               width -= 8;
+                       }
+                       w = width >> 4;
+                       if (w) {
+                               s = (u32 *)src;
+                               d = (u32 *)dst;
+                               w *= BPL / 2;
+                               l = next_line - w * 4;
+                               for (j = height; j > 0; j--) {
+                                       for (i = w; i > 0; i--)
+                                               *d++ = *s++;
+                                       s = (u32 *)((u8 *)s + l);
+                                       d = (u32 *)((u8 *)d + l);
+                               }
+                       }
+                       if (width & 15)
+                               memmove32_col(dst + width / (8 / BPL), src + width / (8 / BPL),
+                                             0xff00ff00, height, next_line - BPL * 2);
+               } else {
+                       src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
+
+                       if ((sx + width) & 15) {
+                               src -= BPL * 2;
+                               dst -= BPL * 2;
+                               memmove32_col(dst, src, 0xff00ff00, colsize, -next_line - BPL * 2);
+                               width -= 8;
+                       }
+                       w = width >> 4;
+                       if (w) {
+                               s = (u32 *)src;
+                               d = (u32 *)dst;
+                               w *= BPL / 2;
+                               l = next_line - w * 4;
+                               for (j = height; j > 0; j--) {
+                                       for (i = w; i > 0; i--)
+                                               *--d = *--s;
+                                       s = (u32 *)((u8 *)s - l);
+                                       d = (u32 *)((u8 *)d - l);
+                               }
+                       }
+                       if (sx & 15)
+                               memmove32_col(dst - (width - 16) / (8 / BPL),
+                                             src - (width - 16) / (8 / BPL),
+                                             0xff00ff, colsize, -next_line - BPL * 2);
+               }
+       } else {
+               /* odd->even or even->odd */
+               if (upwards) {
+                       u32 *src32, *dst32;
+                       u32 pval[4], v, v1, mask;
+                       int i, j, w, f;
+
+                       src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
+
+                       mask = 0xff00ff00;
+                       f = 0;
+                       w = width;
+                       if (sx & 15) {
+                               f = 1;
+                               w += 8;
+                       }
+                       if ((sx + width) & 15)
+                               f |= 2;
+                       w >>= 4;
+                       for (i = height; i; i--) {
+                               src32 = (u32 *)src;
+                               dst32 = (u32 *)dst;
+
+                               if (f & 1) {
+                                       pval[0] = (*src32++ << 8) & mask;
+                               } else {
+                                       pval[0] = dst32[0] & mask;
+                               }
+
+                               for (j = w; j > 0; j--) {
+                                       v = *src32++;
+                                       v1 = v & mask;
+                                       *dst32++ = pval[0] | (v1 >> 8);
+                                       pval[0] = (v ^ v1) << 8;
+                               }
+
+                               if (f & 2) {
+                                       dst32[0] = (dst32[0] & mask) | pval[0];
+                               }
+
+                               src += next_line;
+                               dst += next_line;
+                       }
+               } else {
+                       u32 *src32, *dst32;
+                       u32 pval[4], v, v1, mask;
+                       int i, j, w, f;
+
+                       src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
+
+                       mask = 0xff00ff;
+                       f = 0;
+                       w = width;
+                       if ((dx + width) & 15)
+                               f = 1;
+                       if (sx & 15) {
+                               f |= 2;
+                               w += 8;
+                       }
+                       w >>= 4;
+                       for (i = height; i; i--) {
+                               src32 = (u32 *)src;
+                               dst32 = (u32 *)dst;
+
+                               if (f & 1) {
+                                       pval[0] = dst32[-1] & mask;
+                               } else {
+                                       pval[0] = (*--src32 >> 8) & mask;
+                               }
+
+                               for (j = w; j > 0; j--) {
+                                       v = *--src32;
+                                       v1 = v & mask;
+                                       *--dst32 = pval[0] | (v1 << 8);
+                                       pval[0] = (v ^ v1) >> 8;
+                               }
+
+                               if (!(f & 2)) {
+                                       dst32[-1] = (dst32[-1] & mask) | pval[0];
+                               }
+
+                               src -= next_line;
+                               dst -= next_line;
+                       }
+               }
+       }
+}
+
+void atafb_iplan2p2_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                             int sy, int sx, int height, int width)
+{
+       u32 *dest;
+       int rows, i;
+       u32 cval[4];
+
+       dest = (u32 *)(info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL));
+       if (sx & 15) {
+               u8 *dest8 = (u8 *)dest + 1;
+
+               expand8_col2mask(color, cval);
+
+               for (i = height; i; i--) {
+                       fill8_col(dest8, cval);
+                       dest8 += next_line;
+               }
+               dest += BPL / 2;
+               width -= 8;
+       }
+
+       expand16_col2mask(color, cval);
+       rows = width >> 4;
+       if (rows) {
+               u32 *d = dest;
+               u32 off = next_line - rows * BPL * 2;
+               for (i = height; i; i--) {
+                       d = fill16_col(d, rows, cval);
+                       d = (u32 *)((long)d + off);
+               }
+               dest += rows * BPL / 2;
+               width &= 15;
+       }
+
+       if (width) {
+               u8 *dest8 = (u8 *)dest;
+
+               expand8_col2mask(color, cval);
+
+               for (i = height; i; i--) {
+                       fill8_col(dest8, cval);
+                       dest8 += next_line;
+               }
+       }
+}
+
+void atafb_iplan2p2_linefill(struct fb_info *info, u_long next_line,
+                             int dy, int dx, u32 width,
+                             const u8 *data, u32 bgcolor, u32 fgcolor)
+{
+       u32 *dest;
+       const u16 *data16;
+       int rows;
+       u32 fgm[4], bgm[4], m;
+
+       dest = (u32 *)(info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL));
+       if (dx & 15) {
+               fill8_2col((u8 *)dest + 1, fgcolor, bgcolor, *data++);
+               dest += BPL / 2;
+               width -= 8;
+       }
+
+       if (width >= 16) {
+               data16 = (const u16 *)data;
+               expand16_2col2mask(fgcolor, bgcolor, fgm, bgm);
+
+               for (rows = width / 16; rows; rows--) {
+                       u16 d = *data16++;
+                       m = d | ((u32)d << 16);
+                       *dest++ = (m & fgm[0]) ^ bgm[0];
+               }
+
+               data = (const u8 *)data16;
+               width &= 15;
+       }
+
+       if (width)
+               fill8_2col((u8 *)dest, fgcolor, bgcolor, *data);
+}
+
+#ifdef MODULE
+MODULE_LICENSE("GPL");
+
+int init_module(void)
+{
+       return 0;
+}
+
+void cleanup_module(void)
+{
+}
+#endif /* MODULE */
+
+
+    /*
+     *  Visible symbols for modules
+     */
+
+EXPORT_SYMBOL(atafb_iplan2p2_copyarea);
+EXPORT_SYMBOL(atafb_iplan2p2_fillrect);
+EXPORT_SYMBOL(atafb_iplan2p2_linefill);
diff --git a/drivers/video/atafb_iplan2p4.c b/drivers/video/atafb_iplan2p4.c
new file mode 100644 (file)
index 0000000..bee0d89
--- /dev/null
@@ -0,0 +1,308 @@
+/*
+ *  linux/drivers/video/iplan2p4.c -- Low level frame buffer operations for
+ *                                   interleaved bitplanes à la Atari (4
+ *                                   planes, 2 bytes interleave)
+ *
+ *     Created 5 Apr 1997 by Geert Uytterhoeven
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/fb.h>
+
+#include <asm/setup.h>
+
+#include "atafb.h"
+
+#define BPL    4
+#include "atafb_utils.h"
+
+void atafb_iplan2p4_copyarea(struct fb_info *info, u_long next_line,
+                            int sy, int sx, int dy, int dx,
+                            int height, int width)
+{
+       /*  bmove() has to distinguish two major cases: If both, source and
+        *  destination, start at even addresses or both are at odd
+        *  addresses, just the first odd and last even column (if present)
+        *  require special treatment (memmove_col()). The rest between
+        *  then can be copied by normal operations, because all adjacent
+        *  bytes are affected and are to be stored in the same order.
+        *    The pathological case is when the move should go from an odd
+        *  address to an even or vice versa. Since the bytes in the plane
+        *  words must be assembled in new order, it seems wisest to make
+        *  all movements by memmove_col().
+        */
+
+       u8 *src, *dst;
+       u32 *s, *d;
+       int w, l , i, j;
+       u_int colsize;
+       u_int upwards = (dy < sy) || (dy == sy && dx < sx);
+
+       colsize = height;
+       if (!((sx ^ dx) & 15)) {
+               /* odd->odd or even->even */
+
+               if (upwards) {
+                       src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
+                       if (sx & 15) {
+                               memmove32_col(dst, src, 0xff00ff, height, next_line - BPL * 2);
+                               src += BPL * 2;
+                               dst += BPL * 2;
+                               width -= 8;
+                       }
+                       w = width >> 4;
+                       if (w) {
+                               s = (u32 *)src;
+                               d = (u32 *)dst;
+                               w *= BPL / 2;
+                               l = next_line - w * 4;
+                               for (j = height; j > 0; j--) {
+                                       for (i = w; i > 0; i--)
+                                               *d++ = *s++;
+                                       s = (u32 *)((u8 *)s + l);
+                                       d = (u32 *)((u8 *)d + l);
+                               }
+                       }
+                       if (width & 15)
+                               memmove32_col(dst + width / (8 / BPL), src + width / (8 / BPL),
+                                             0xff00ff00, height, next_line - BPL * 2);
+               } else {
+                       src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
+
+                       if ((sx + width) & 15) {
+                               src -= BPL * 2;
+                               dst -= BPL * 2;
+                               memmove32_col(dst, src, 0xff00ff00, colsize, -next_line - BPL * 2);
+                               width -= 8;
+                       }
+                       w = width >> 4;
+                       if (w) {
+                               s = (u32 *)src;
+                               d = (u32 *)dst;
+                               w *= BPL / 2;
+                               l = next_line - w * 4;
+                               for (j = height; j > 0; j--) {
+                                       for (i = w; i > 0; i--)
+                                               *--d = *--s;
+                                       s = (u32 *)((u8 *)s - l);
+                                       d = (u32 *)((u8 *)d - l);
+                               }
+                       }
+                       if (sx & 15)
+                               memmove32_col(dst - (width - 16) / (8 / BPL),
+                                             src - (width - 16) / (8 / BPL),
+                                             0xff00ff, colsize, -next_line - BPL * 2);
+               }
+       } else {
+               /* odd->even or even->odd */
+               if (upwards) {
+                       u32 *src32, *dst32;
+                       u32 pval[4], v, v1, mask;
+                       int i, j, w, f;
+
+                       src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
+
+                       mask = 0xff00ff00;
+                       f = 0;
+                       w = width;
+                       if (sx & 15) {
+                               f = 1;
+                               w += 8;
+                       }
+                       if ((sx + width) & 15)
+                               f |= 2;
+                       w >>= 4;
+                       for (i = height; i; i--) {
+                               src32 = (u32 *)src;
+                               dst32 = (u32 *)dst;
+
+                               if (f & 1) {
+                                       pval[0] = (*src32++ << 8) & mask;
+                                       pval[1] = (*src32++ << 8) & mask;
+                               } else {
+                                       pval[0] = dst32[0] & mask;
+                                       pval[1] = dst32[1] & mask;
+                               }
+
+                               for (j = w; j > 0; j--) {
+                                       v = *src32++;
+                                       v1 = v & mask;
+                                       *dst32++ = pval[0] | (v1 >> 8);
+                                       pval[0] = (v ^ v1) << 8;
+                                       v = *src32++;
+                                       v1 = v & mask;
+                                       *dst32++ = pval[1] | (v1 >> 8);
+                                       pval[1] = (v ^ v1) << 8;
+                               }
+
+                               if (f & 2) {
+                                       dst32[0] = (dst32[0] & mask) | pval[0];
+                                       dst32[1] = (dst32[1] & mask) | pval[1];
+                               }
+
+                               src += next_line;
+                               dst += next_line;
+                       }
+               } else {
+                       u32 *src32, *dst32;
+                       u32 pval[4], v, v1, mask;
+                       int i, j, w, f;
+
+                       src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
+
+                       mask = 0xff00ff;
+                       f = 0;
+                       w = width;
+                       if ((dx + width) & 15)
+                               f = 1;
+                       if (sx & 15) {
+                               f |= 2;
+                               w += 8;
+                       }
+                       w >>= 4;
+                       for (i = height; i; i--) {
+                               src32 = (u32 *)src;
+                               dst32 = (u32 *)dst;
+
+                               if (f & 1) {
+                                       pval[0] = dst32[-1] & mask;
+                                       pval[1] = dst32[-2] & mask;
+                               } else {
+                                       pval[0] = (*--src32 >> 8) & mask;
+                                       pval[1] = (*--src32 >> 8) & mask;
+                               }
+
+                               for (j = w; j > 0; j--) {
+                                       v = *--src32;
+                                       v1 = v & mask;
+                                       *--dst32 = pval[0] | (v1 << 8);
+                                       pval[0] = (v ^ v1) >> 8;
+                                       v = *--src32;
+                                       v1 = v & mask;
+                                       *--dst32 = pval[1] | (v1 << 8);
+                                       pval[1] = (v ^ v1) >> 8;
+                               }
+
+                               if (!(f & 2)) {
+                                       dst32[-1] = (dst32[-1] & mask) | pval[0];
+                                       dst32[-2] = (dst32[-2] & mask) | pval[1];
+                               }
+
+                               src -= next_line;
+                               dst -= next_line;
+                       }
+               }
+       }
+}
+
+void atafb_iplan2p4_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                             int sy, int sx, int height, int width)
+{
+       u32 *dest;
+       int rows, i;
+       u32 cval[4];
+
+       dest = (u32 *)(info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL));
+       if (sx & 15) {
+               u8 *dest8 = (u8 *)dest + 1;
+
+               expand8_col2mask(color, cval);
+
+               for (i = height; i; i--) {
+                       fill8_col(dest8, cval);
+                       dest8 += next_line;
+               }
+               dest += BPL / 2;
+               width -= 8;
+       }
+
+       expand16_col2mask(color, cval);
+       rows = width >> 4;
+       if (rows) {
+               u32 *d = dest;
+               u32 off = next_line - rows * BPL * 2;
+               for (i = height; i; i--) {
+                       d = fill16_col(d, rows, cval);
+                       d = (u32 *)((long)d + off);
+               }
+               dest += rows * BPL / 2;
+               width &= 15;
+       }
+
+       if (width) {
+               u8 *dest8 = (u8 *)dest;
+
+               expand8_col2mask(color, cval);
+
+               for (i = height; i; i--) {
+                       fill8_col(dest8, cval);
+                       dest8 += next_line;
+               }
+       }
+}
+
+void atafb_iplan2p4_linefill(struct fb_info *info, u_long next_line,
+                             int dy, int dx, u32 width,
+                             const u8 *data, u32 bgcolor, u32 fgcolor)
+{
+       u32 *dest;
+       const u16 *data16;
+       int rows;
+       u32 fgm[4], bgm[4], m;
+
+       dest = (u32 *)(info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL));
+       if (dx & 15) {
+               fill8_2col((u8 *)dest + 1, fgcolor, bgcolor, *data++);
+               dest += BPL / 2;
+               width -= 8;
+       }
+
+       if (width >= 16) {
+               data16 = (const u16 *)data;
+               expand16_2col2mask(fgcolor, bgcolor, fgm, bgm);
+
+               for (rows = width / 16; rows; rows--) {
+                       u16 d = *data16++;
+                       m = d | ((u32)d << 16);
+                       *dest++ = (m & fgm[0]) ^ bgm[0];
+                       *dest++ = (m & fgm[1]) ^ bgm[1];
+               }
+
+               data = (const u8 *)data16;
+               width &= 15;
+       }
+
+       if (width)
+               fill8_2col((u8 *)dest, fgcolor, bgcolor, *data);
+}
+
+#ifdef MODULE
+MODULE_LICENSE("GPL");
+
+int init_module(void)
+{
+       return 0;
+}
+
+void cleanup_module(void)
+{
+}
+#endif /* MODULE */
+
+
+    /*
+     *  Visible symbols for modules
+     */
+
+EXPORT_SYMBOL(atafb_iplan2p4_copyarea);
+EXPORT_SYMBOL(atafb_iplan2p4_fillrect);
+EXPORT_SYMBOL(atafb_iplan2p4_linefill);
diff --git a/drivers/video/atafb_iplan2p8.c b/drivers/video/atafb_iplan2p8.c
new file mode 100644 (file)
index 0000000..356fb52
--- /dev/null
@@ -0,0 +1,345 @@
+/*
+ *  linux/drivers/video/iplan2p8.c -- Low level frame buffer operations for
+ *                                   interleaved bitplanes à la Atari (8
+ *                                   planes, 2 bytes interleave)
+ *
+ *     Created 5 Apr 1997 by Geert Uytterhoeven
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/fb.h>
+
+#include <asm/setup.h>
+
+#include "atafb.h"
+
+#define BPL    8
+#include "atafb_utils.h"
+
+
+/* Copies a 8 plane column from 's', height 'h', to 'd'. */
+
+/* This expands a 8 bit color into two longs for two movepl (8 plane)
+ * operations.
+ */
+
+void atafb_iplan2p8_copyarea(struct fb_info *info, u_long next_line,
+                            int sy, int sx, int dy, int dx,
+                            int height, int width)
+{
+       /*  bmove() has to distinguish two major cases: If both, source and
+        *  destination, start at even addresses or both are at odd
+        *  addresses, just the first odd and last even column (if present)
+        *  require special treatment (memmove_col()). The rest between
+        *  then can be copied by normal operations, because all adjacent
+        *  bytes are affected and are to be stored in the same order.
+        *    The pathological case is when the move should go from an odd
+        *  address to an even or vice versa. Since the bytes in the plane
+        *  words must be assembled in new order, it seems wisest to make
+        *  all movements by memmove_col().
+        */
+
+       u8 *src, *dst;
+       u32 *s, *d;
+       int w, l , i, j;
+       u_int colsize;
+       u_int upwards = (dy < sy) || (dy == sy && dx < sx);
+
+       colsize = height;
+       if (!((sx ^ dx) & 15)) {
+               /* odd->odd or even->even */
+
+               if (upwards) {
+                       src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
+                       if (sx & 15) {
+                               memmove32_col(dst, src, 0xff00ff, height, next_line - BPL * 2);
+                               src += BPL * 2;
+                               dst += BPL * 2;
+                               width -= 8;
+                       }
+                       w = width >> 4;
+                       if (w) {
+                               s = (u32 *)src;
+                               d = (u32 *)dst;
+                               w *= BPL / 2;
+                               l = next_line - w * 4;
+                               for (j = height; j > 0; j--) {
+                                       for (i = w; i > 0; i--)
+                                               *d++ = *s++;
+                                       s = (u32 *)((u8 *)s + l);
+                                       d = (u32 *)((u8 *)d + l);
+                               }
+                       }
+                       if (width & 15)
+                               memmove32_col(dst + width / (8 / BPL), src + width / (8 / BPL),
+                                             0xff00ff00, height, next_line - BPL * 2);
+               } else {
+                       src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
+
+                       if ((sx + width) & 15) {
+                               src -= BPL * 2;
+                               dst -= BPL * 2;
+                               memmove32_col(dst, src, 0xff00ff00, colsize, -next_line - BPL * 2);
+                               width -= 8;
+                       }
+                       w = width >> 4;
+                       if (w) {
+                               s = (u32 *)src;
+                               d = (u32 *)dst;
+                               w *= BPL / 2;
+                               l = next_line - w * 4;
+                               for (j = height; j > 0; j--) {
+                                       for (i = w; i > 0; i--)
+                                               *--d = *--s;
+                                       s = (u32 *)((u8 *)s - l);
+                                       d = (u32 *)((u8 *)d - l);
+                               }
+                       }
+                       if (sx & 15)
+                               memmove32_col(dst - (width - 16) / (8 / BPL),
+                                             src - (width - 16) / (8 / BPL),
+                                             0xff00ff, colsize, -next_line - BPL * 2);
+               }
+       } else {
+               /* odd->even or even->odd */
+               if (upwards) {
+                       u32 *src32, *dst32;
+                       u32 pval[4], v, v1, mask;
+                       int i, j, w, f;
+
+                       src = (u8 *)info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);
+
+                       mask = 0xff00ff00;
+                       f = 0;
+                       w = width;
+                       if (sx & 15) {
+                               f = 1;
+                               w += 8;
+                       }
+                       if ((sx + width) & 15)
+                               f |= 2;
+                       w >>= 4;
+                       for (i = height; i; i--) {
+                               src32 = (u32 *)src;
+                               dst32 = (u32 *)dst;
+
+                               if (f & 1) {
+                                       pval[0] = (*src32++ << 8) & mask;
+                                       pval[1] = (*src32++ << 8) & mask;
+                                       pval[2] = (*src32++ << 8) & mask;
+                                       pval[3] = (*src32++ << 8) & mask;
+                               } else {
+                                       pval[0] = dst32[0] & mask;
+                                       pval[1] = dst32[1] & mask;
+                                       pval[2] = dst32[2] & mask;
+                                       pval[3] = dst32[3] & mask;
+                               }
+
+                               for (j = w; j > 0; j--) {
+                                       v = *src32++;
+                                       v1 = v & mask;
+                                       *dst32++ = pval[0] | (v1 >> 8);
+                                       pval[0] = (v ^ v1) << 8;
+                                       v = *src32++;
+                                       v1 = v & mask;
+                                       *dst32++ = pval[1] | (v1 >> 8);
+                                       pval[1] = (v ^ v1) << 8;
+                                       v = *src32++;
+                                       v1 = v & mask;
+                                       *dst32++ = pval[2] | (v1 >> 8);
+                                       pval[2] = (v ^ v1) << 8;
+                                       v = *src32++;
+                                       v1 = v & mask;
+                                       *dst32++ = pval[3] | (v1 >> 8);
+                                       pval[3] = (v ^ v1) << 8;
+                               }
+
+                               if (f & 2) {
+                                       dst32[0] = (dst32[0] & mask) | pval[0];
+                                       dst32[1] = (dst32[1] & mask) | pval[1];
+                                       dst32[2] = (dst32[2] & mask) | pval[2];
+                                       dst32[3] = (dst32[3] & mask) | pval[3];
+                               }
+
+                               src += next_line;
+                               dst += next_line;
+                       }
+               } else {
+                       u32 *src32, *dst32;
+                       u32 pval[4], v, v1, mask;
+                       int i, j, w, f;
+
+                       src = (u8 *)info->screen_base + (sy - 1) * next_line + ((sx + width + 8) & ~15) / (8 / BPL);
+                       dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);
+
+                       mask = 0xff00ff;
+                       f = 0;
+                       w = width;
+                       if ((dx + width) & 15)
+                               f = 1;
+                       if (sx & 15) {
+                               f |= 2;
+                               w += 8;
+                       }
+                       w >>= 4;
+                       for (i = height; i; i--) {
+                               src32 = (u32 *)src;
+                               dst32 = (u32 *)dst;
+
+                               if (f & 1) {
+                                       pval[0] = dst32[-1] & mask;
+                                       pval[1] = dst32[-2] & mask;
+                                       pval[2] = dst32[-3] & mask;
+                                       pval[3] = dst32[-4] & mask;
+                               } else {
+                                       pval[0] = (*--src32 >> 8) & mask;
+                                       pval[1] = (*--src32 >> 8) & mask;
+                                       pval[2] = (*--src32 >> 8) & mask;
+                                       pval[3] = (*--src32 >> 8) & mask;
+                               }
+
+                               for (j = w; j > 0; j--) {
+                                       v = *--src32;
+                                       v1 = v & mask;
+                                       *--dst32 = pval[0] | (v1 << 8);
+                                       pval[0] = (v ^ v1) >> 8;
+                                       v = *--src32;
+                                       v1 = v & mask;
+                                       *--dst32 = pval[1] | (v1 << 8);
+                                       pval[1] = (v ^ v1) >> 8;
+                                       v = *--src32;
+                                       v1 = v & mask;
+                                       *--dst32 = pval[2] | (v1 << 8);
+                                       pval[2] = (v ^ v1) >> 8;
+                                       v = *--src32;
+                                       v1 = v & mask;
+                                       *--dst32 = pval[3] | (v1 << 8);
+                                       pval[3] = (v ^ v1) >> 8;
+                               }
+
+                               if (!(f & 2)) {
+                                       dst32[-1] = (dst32[-1] & mask) | pval[0];
+                                       dst32[-2] = (dst32[-2] & mask) | pval[1];
+                                       dst32[-3] = (dst32[-3] & mask) | pval[2];
+                                       dst32[-4] = (dst32[-4] & mask) | pval[3];
+                               }
+
+                               src -= next_line;
+                               dst -= next_line;
+                       }
+               }
+       }
+}
+
+void atafb_iplan2p8_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                             int sy, int sx, int height, int width)
+{
+       u32 *dest;
+       int rows, i;
+       u32 cval[4];
+
+       dest = (u32 *)(info->screen_base + sy * next_line + (sx & ~15) / (8 / BPL));
+       if (sx & 15) {
+               u8 *dest8 = (u8 *)dest + 1;
+
+               expand8_col2mask(color, cval);
+
+               for (i = height; i; i--) {
+                       fill8_col(dest8, cval);
+                       dest8 += next_line;
+               }
+               dest += BPL / 2;
+               width -= 8;
+       }
+
+       expand16_col2mask(color, cval);
+       rows = width >> 4;
+       if (rows) {
+               u32 *d = dest;
+               u32 off = next_line - rows * BPL * 2;
+               for (i = height; i; i--) {
+                       d = fill16_col(d, rows, cval);
+                       d = (u32 *)((long)d + off);
+               }
+               dest += rows * BPL / 2;
+               width &= 15;
+       }
+
+       if (width) {
+               u8 *dest8 = (u8 *)dest;
+
+               expand8_col2mask(color, cval);
+
+               for (i = height; i; i--) {
+                       fill8_col(dest8, cval);
+                       dest8 += next_line;
+               }
+       }
+}
+
+void atafb_iplan2p8_linefill(struct fb_info *info, u_long next_line,
+                            int dy, int dx, u32 width,
+                            const u8 *data, u32 bgcolor, u32 fgcolor)
+{
+       u32 *dest;
+       const u16 *data16;
+       int rows;
+       u32 fgm[4], bgm[4], m;
+
+       dest = (u32 *)(info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL));
+       if (dx & 15) {
+               fill8_2col((u8 *)dest + 1, fgcolor, bgcolor, *data++);
+               dest += BPL / 2;
+               width -= 8;
+       }
+
+       if (width >= 16) {
+               data16 = (const u16 *)data;
+               expand16_2col2mask(fgcolor, bgcolor, fgm, bgm);
+
+               for (rows = width / 16; rows; rows--) {
+                       u16 d = *data16++;
+                       m = d | ((u32)d << 16);
+                       *dest++ = (m & fgm[0]) ^ bgm[0];
+                       *dest++ = (m & fgm[1]) ^ bgm[1];
+                       *dest++ = (m & fgm[2]) ^ bgm[2];
+                       *dest++ = (m & fgm[3]) ^ bgm[3];
+               }
+
+               data = (const u8 *)data16;
+               width &= 15;
+       }
+
+       if (width)
+               fill8_2col((u8 *)dest, fgcolor, bgcolor, *data);
+}
+
+#ifdef MODULE
+MODULE_LICENSE("GPL");
+
+int init_module(void)
+{
+       return 0;
+}
+
+void cleanup_module(void)
+{
+}
+#endif /* MODULE */
+
+
+    /*
+     *  Visible symbols for modules
+     */
+
+EXPORT_SYMBOL(atafb_iplan2p8_copyarea);
+EXPORT_SYMBOL(atafb_iplan2p8_fillrect);
+EXPORT_SYMBOL(atafb_iplan2p8_linefill);
diff --git a/drivers/video/atafb_mfb.c b/drivers/video/atafb_mfb.c
new file mode 100644 (file)
index 0000000..6a352d6
--- /dev/null
@@ -0,0 +1,112 @@
+/*
+ *  linux/drivers/video/mfb.c -- Low level frame buffer operations for
+ *                              monochrome
+ *
+ *     Created 5 Apr 1997 by Geert Uytterhoeven
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/fb.h>
+
+#include "atafb.h"
+#include "atafb_utils.h"
+
+
+    /*
+     *  Monochrome
+     */
+
+void atafb_mfb_copyarea(struct fb_info *info, u_long next_line,
+                       int sy, int sx, int dy, int dx,
+                       int height, int width)
+{
+       u8 *src, *dest;
+       u_int rows;
+
+       if (sx == 0 && dx == 0 && width == next_line) {
+               src = (u8 *)info->screen_base + sy * (width >> 3);
+               dest = (u8 *)info->screen_base + dy * (width >> 3);
+               fb_memmove(dest, src, height * (width >> 3));
+       } else if (dy <= sy) {
+               src = (u8 *)info->screen_base + sy * next_line + (sx >> 3);
+               dest = (u8 *)info->screen_base + dy * next_line + (dx >> 3);
+               for (rows = height; rows--;) {
+                       fb_memmove(dest, src, width >> 3);
+                       src += next_line;
+                       dest += next_line;
+               }
+       } else {
+               src = (u8 *)info->screen_base + (sy + height - 1) * next_line + (sx >> 3);
+               dest = (u8 *)info->screen_base + (dy + height - 1) * next_line + (dx >> 3);
+               for (rows = height; rows--;) {
+                       fb_memmove(dest, src, width >> 3);
+                       src -= next_line;
+                       dest -= next_line;
+               }
+       }
+}
+
+void atafb_mfb_fillrect(struct fb_info *info, u_long next_line, u32 color,
+                       int sy, int sx, int height, int width)
+{
+       u8 *dest;
+       u_int rows;
+
+       dest = (u8 *)info->screen_base + sy * next_line + (sx >> 3);
+
+       if (sx == 0 && width == next_line) {
+               if (color)
+                       fb_memset255(dest, height * (width >> 3));
+               else
+                       fb_memclear(dest, height * (width >> 3));
+       } else {
+               for (rows = height; rows--; dest += next_line) {
+                       if (color)
+                               fb_memset255(dest, width >> 3);
+                       else
+                               fb_memclear_small(dest, width >> 3);
+               }
+       }
+}
+
+void atafb_mfb_linefill(struct fb_info *info, u_long next_line,
+                       int dy, int dx, u32 width,
+                       const u8 *data, u32 bgcolor, u32 fgcolor)
+{
+       u8 *dest;
+       u_int rows;
+
+       dest = (u8 *)info->screen_base + dy * next_line + (dx >> 3);
+
+       for (rows = width / 8; rows--; /* check margins */ ) {
+               // use fast_memmove or fb_memmove
+               *dest++ = *data++;
+       }
+}
+
+#ifdef MODULE
+MODULE_LICENSE("GPL");
+
+int init_module(void)
+{
+       return 0;
+}
+
+void cleanup_module(void)
+{
+}
+#endif /* MODULE */
+
+
+    /*
+     *  Visible symbols for modules
+     */
+
+EXPORT_SYMBOL(atafb_mfb_copyarea);
+EXPORT_SYMBOL(atafb_mfb_fillrect);
+EXPORT_SYMBOL(atafb_mfb_linefill);
diff --git a/drivers/video/atafb_utils.h b/drivers/video/atafb_utils.h
new file mode 100644 (file)
index 0000000..ac9e19d
--- /dev/null
@@ -0,0 +1,400 @@
+#ifndef _VIDEO_ATAFB_UTILS_H
+#define _VIDEO_ATAFB_UTILS_H
+
+/* ================================================================= */
+/*                      Utility Assembler Functions                  */
+/* ================================================================= */
+
+/* ====================================================================== */
+
+/* Those of a delicate disposition might like to skip the next couple of
+ * pages.
+ *
+ * These functions are drop in replacements for memmove and
+ * memset(_, 0, _). However their five instances add at least a kilobyte
+ * to the object file. You have been warned.
+ *
+ * Not a great fan of assembler for the sake of it, but I think
+ * that these routines are at least 10 times faster than their C
+ * equivalents for large blits, and that's important to the lowest level of
+ * a graphics driver. Question is whether some scheme with the blitter
+ * would be faster. I suspect not for simple text system - not much
+ * asynchrony.
+ *
+ * Code is very simple, just gruesome expansion. Basic strategy is to
+ * increase data moved/cleared at each step to 16 bytes to reduce
+ * instruction per data move overhead. movem might be faster still
+ * For more than 15 bytes, we try to align the write direction on a
+ * longword boundary to get maximum speed. This is even more gruesome.
+ * Unaligned read/write used requires 68020+ - think this is a problem?
+ *
+ * Sorry!
+ */
+
+
+/* ++roman: I've optimized Robert's original versions in some minor
+ * aspects, e.g. moveq instead of movel, let gcc choose the registers,
+ * use movem in some places...
+ * For other modes than 1 plane, lots of more such assembler functions
+ * were needed (e.g. the ones using movep or expanding color values).
+ */
+
+/* ++andreas: more optimizations:
+   subl #65536,d0 replaced by clrw d0; subql #1,d0 for dbcc
+   addal is faster than addaw
+   movep is rather expensive compared to ordinary move's
+   some functions rewritten in C for clarity, no speed loss */
+
+static inline void *fb_memclear_small(void *s, size_t count)
+{
+       if (!count)
+               return 0;
+
+       asm volatile ("\n"
+               "       lsr.l   #1,%1 ; jcc 1f ; move.b %2,-(%0)\n"
+               "1:     lsr.l   #1,%1 ; jcc 1f ; move.w %2,-(%0)\n"
+               "1:     lsr.l   #1,%1 ; jcc 1f ; move.l %2,-(%0)\n"
+               "1:     lsr.l   #1,%1 ; jcc 1f ; move.l %2,-(%0) ; move.l %2,-(%0)\n"
+               "1:"
+               : "=a" (s), "=d" (count)
+               : "d" (0), "0" ((char *)s + count), "1" (count));
+       asm volatile ("\n"
+               "       subq.l  #1,%1\n"
+               "       jcs     3f\n"
+               "       move.l  %2,%%d4; move.l %2,%%d5; move.l %2,%%d6\n"
+               "2:     movem.l %2/%%d4/%%d5/%%d6,-(%0)\n"
+               "       dbra    %1,2b\n"
+               "3:"
+               : "=a" (s), "=d" (count)
+               : "d" (0), "0" (s), "1" (count)
+               : "d4", "d5", "d6"
+               );
+
+       return 0;
+}
+
+
+static inline void *fb_memclear(void *s, size_t count)
+{
+       if (!count)
+               return 0;
+
+       if (count < 16) {
+               asm volatile ("\n"
+                       "       lsr.l   #1,%1 ; jcc 1f ; clr.b (%0)+\n"
+                       "1:     lsr.l   #1,%1 ; jcc 1f ; clr.w (%0)+\n"
+                       "1:     lsr.l   #1,%1 ; jcc 1f ; clr.l (%0)+\n"
+                       "1:     lsr.l   #1,%1 ; jcc 1f ; clr.l (%0)+ ; clr.l (%0)+\n"
+                       "1:"
+                       : "=a" (s), "=d" (count)
+                       : "0" (s), "1" (count));
+       } else {
+               long tmp;
+               asm volatile ("\n"
+                       "       move.l  %1,%2\n"
+                       "       lsr.l   #1,%2 ; jcc 1f ; clr.b (%0)+ ; subq.w #1,%1\n"
+                       "       lsr.l   #1,%2 ; jcs 2f\n"  /* %0 increased=>bit 2 switched*/
+                       "       clr.w   (%0)+  ; subq.w  #2,%1 ; jra 2f\n"
+                       "1:     lsr.l   #1,%2 ; jcc 2f\n"
+                       "       clr.w   (%0)+  ; subq.w  #2,%1\n"
+                       "2:     move.w  %1,%2; lsr.l #2,%1 ; jeq 6f\n"
+                       "       lsr.l   #1,%1 ; jcc 3f ; clr.l (%0)+\n"
+                       "3:     lsr.l   #1,%1 ; jcc 4f ; clr.l (%0)+ ; clr.l (%0)+\n"
+                       "4:     subq.l  #1,%1 ; jcs 6f\n"
+                       "5:     clr.l   (%0)+; clr.l (%0)+ ; clr.l (%0)+ ; clr.l (%0)+\n"
+                       "       dbra    %1,5b ; clr.w %1; subq.l #1,%1; jcc 5b\n"
+                       "6:     move.w  %2,%1; btst #1,%1 ; jeq 7f ; clr.w (%0)+\n"
+                       "7:     btst    #0,%1 ; jeq 8f ; clr.b (%0)+\n"
+                       "8:"
+                       : "=a" (s), "=d" (count), "=d" (tmp)
+                       : "0" (s), "1" (count));
+       }
+
+       return 0;
+}
+
+
+static inline void *fb_memset255(void *s, size_t count)
+{
+       if (!count)
+               return 0;
+
+       asm volatile ("\n"
+               "       lsr.l   #1,%1 ; jcc 1f ; move.b %2,-(%0)\n"
+               "1:     lsr.l   #1,%1 ; jcc 1f ; move.w %2,-(%0)\n"
+               "1:     lsr.l   #1,%1 ; jcc 1f ; move.l %2,-(%0)\n"
+               "1:     lsr.l   #1,%1 ; jcc 1f ; move.l %2,-(%0) ; move.l %2,-(%0)\n"
+               "1:"
+               : "=a" (s), "=d" (count)
+               : "d" (-1), "0" ((char *)s+count), "1" (count));
+       asm volatile ("\n"
+               "       subq.l  #1,%1 ; jcs 3f\n"
+               "       move.l  %2,%%d4; move.l %2,%%d5; move.l %2,%%d6\n"
+               "2:     movem.l %2/%%d4/%%d5/%%d6,-(%0)\n"
+               "       dbra    %1,2b\n"
+               "3:"
+               : "=a" (s), "=d" (count)
+               : "d" (-1), "0" (s), "1" (count)
+               : "d4", "d5", "d6");
+
+       return 0;
+}
+
+
+static inline void *fb_memmove(void *d, const void *s, size_t count)
+{
+       if (d < s) {
+               if (count < 16) {
+                       asm volatile ("\n"
+                               "       lsr.l   #1,%2 ; jcc 1f ; move.b (%1)+,(%0)+\n"
+                               "1:     lsr.l   #1,%2 ; jcc 1f ; move.w (%1)+,(%0)+\n"
+                               "1:     lsr.l   #1,%2 ; jcc 1f ; move.l (%1)+,(%0)+\n"
+                               "1:     lsr.l   #1,%2 ; jcc 1f ; move.l (%1)+,(%0)+ ; move.l (%1)+,(%0)+\n"
+                               "1:"
+                               : "=a" (d), "=a" (s), "=d" (count)
+                               : "0" (d), "1" (s), "2" (count));
+               } else {
+                       long tmp;
+                       asm volatile ("\n"
+                               "       move.l  %0,%3\n"
+                               "       lsr.l   #1,%3 ; jcc 1f ; move.b (%1)+,(%0)+ ; subqw #1,%2\n"
+                               "       lsr.l   #1,%3 ; jcs 2f\n"  /* %0 increased=>bit 2 switched*/
+                               "       move.w  (%1)+,(%0)+  ; subqw  #2,%2 ; jra 2f\n"
+                               "1:     lsr.l   #1,%3 ; jcc 2f\n"
+                               "       move.w  (%1)+,(%0)+  ; subqw  #2,%2\n"
+                               "2:     move.w  %2,%-; lsr.l #2,%2 ; jeq 6f\n"
+                               "       lsr.l   #1,%2 ; jcc 3f ; move.l (%1)+,(%0)+\n"
+                               "3:     lsr.l   #1,%2 ; jcc 4f ; move.l (%1)+,(%0)+ ; move.l (%1)+,(%0)+\n"
+                               "4:     subq.l  #1,%2 ; jcs 6f\n"
+                               "5:     move.l  (%1)+,(%0)+; move.l (%1)+,(%0)+\n"
+                               "       move.l  (%1)+,(%0)+; move.l (%1)+,(%0)+\n"
+                               "       dbra    %2,5b ; clr.w %2; subq.l #1,%2; jcc 5b\n"
+                               "6:     move.w  %+,%2; btst #1,%2 ; jeq 7f ; move.w (%1)+,(%0)+\n"
+                               "7:     btst    #0,%2 ; jeq 8f ; move.b (%1)+,(%0)+\n"
+                               "8:"
+                               : "=a" (d), "=a" (s), "=d" (count), "=d" (tmp)
+                               : "0" (d), "1" (s), "2" (count));
+               }
+       } else {
+               if (count < 16) {
+                       asm volatile ("\n"
+                               "       lsr.l   #1,%2 ; jcc 1f ; move.b -(%1),-(%0)\n"
+                               "1:     lsr.l   #1,%2 ; jcc 1f ; move.w -(%1),-(%0)\n"
+                               "1:     lsr.l   #1,%2 ; jcc 1f ; move.l -(%1),-(%0)\n"
+                               "1:     lsr.l   #1,%2 ; jcc 1f ; move.l -(%1),-(%0) ; move.l -(%1),-(%0)\n"
+                               "1:"
+                               : "=a" (d), "=a" (s), "=d" (count)
+                               : "0" ((char *) d + count), "1" ((char *) s + count), "2" (count));
+               } else {
+                       long tmp;
+
+                       asm volatile ("\n"
+                               "       move.l  %0,%3\n"
+                               "       lsr.l   #1,%3 ; jcc 1f ; move.b -(%1),-(%0) ; subqw #1,%2\n"
+                               "       lsr.l   #1,%3 ; jcs 2f\n"  /* %0 increased=>bit 2 switched*/
+                               "       move.w  -(%1),-(%0) ; subqw  #2,%2 ; jra 2f\n"
+                               "1:     lsr.l   #1,%3 ; jcc 2f\n"
+                               "       move.w  -(%1),-(%0) ; subqw  #2,%2\n"
+                               "2:     move.w  %2,%-; lsr.l #2,%2 ; jeq 6f\n"
+                               "       lsr.l   #1,%2 ; jcc 3f ; move.l -(%1),-(%0)\n"
+                               "3:     lsr.l   #1,%2 ; jcc 4f ; move.l -(%1),-(%0) ; move.l -(%1),-(%0)\n"
+                               "4:     subq.l  #1,%2 ; jcs 6f\n"
+                               "5:     move.l  -(%1),-(%0); move.l -(%1),-(%0)\n"
+                               "       move.l  -(%1),-(%0); move.l -(%1),-(%0)\n"
+                               "       dbra    %2,5b ; clr.w %2; subq.l #1,%2; jcc 5b\n"
+                               "6:     move.w  %+,%2; btst #1,%2 ; jeq 7f ; move.w -(%1),-(%0)\n"
+                               "7:     btst    #0,%2 ; jeq 8f ; move.b -(%1),-(%0)\n"
+                               "8:"
+                               : "=a" (d), "=a" (s), "=d" (count), "=d" (tmp)
+                               : "0" ((char *) d + count), "1" ((char *) s + count), "2" (count));
+               }
+       }
+
+       return 0;
+}
+
+
+/* ++andreas: Simple and fast version of memmove, assumes size is
+   divisible by 16, suitable for moving the whole screen bitplane */
+static inline void fast_memmove(char *dst, const char *src, size_t size)
+{
+       if (!size)
+               return;
+       if (dst < src)
+               asm volatile ("\n"
+                       "1:     movem.l (%0)+,%%d0/%%d1/%%a0/%%a1\n"
+                       "       movem.l %%d0/%%d1/%%a0/%%a1,%1@\n"
+                       "       addq.l  #8,%1; addq.l #8,%1\n"
+                       "       dbra    %2,1b\n"
+                       "       clr.w   %2; subq.l #1,%2\n"
+                       "       jcc     1b"
+                       : "=a" (src), "=a" (dst), "=d" (size)
+                       : "0" (src), "1" (dst), "2" (size / 16 - 1)
+                       : "d0", "d1", "a0", "a1", "memory");
+       else
+               asm volatile ("\n"
+                       "1:     subq.l  #8,%0; subq.l #8,%0\n"
+                       "       movem.l %0@,%%d0/%%d1/%%a0/%%a1\n"
+                       "       movem.l %%d0/%%d1/%%a0/%%a1,-(%1)\n"
+                       "       dbra    %2,1b\n"
+                       "       clr.w   %2; subq.l #1,%2\n"
+                       "       jcc 1b"
+                       : "=a" (src), "=a" (dst), "=d" (size)
+                       : "0" (src + size), "1" (dst + size), "2" (size / 16 - 1)
+                       : "d0", "d1", "a0", "a1", "memory");
+}
+
+#ifdef BPL
+
+/*
+ * This expands a up to 8 bit color into two longs
+ * for movel operations.
+ */
+static const u32 four2long[] = {
+       0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
+       0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
+       0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
+       0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff,
+};
+
+static inline void expand8_col2mask(u8 c, u32 m[])
+{
+       m[0] = four2long[c & 15];
+#if BPL > 4
+       m[1] = four2long[c >> 4];
+#endif
+}
+
+static inline void expand8_2col2mask(u8 fg, u8 bg, u32 fgm[], u32 bgm[])
+{
+       fgm[0] = four2long[fg & 15] ^ (bgm[0] = four2long[bg & 15]);
+#if BPL > 4
+       fgm[1] = four2long[fg >> 4] ^ (bgm[1] = four2long[bg >> 4]);
+#endif
+}
+
+/*
+ * set an 8bit value to a color
+ */
+static inline void fill8_col(u8 *dst, u32 m[])
+{
+       u32 tmp = m[0];
+       dst[0] = tmp;
+       dst[2] = (tmp >>= 8);
+#if BPL > 2
+       dst[4] = (tmp >>= 8);
+       dst[6] = tmp >> 8;
+#endif
+#if BPL > 4
+       tmp = m[1];
+       dst[8] = tmp;
+       dst[10] = (tmp >>= 8);
+       dst[12] = (tmp >>= 8);
+       dst[14] = tmp >> 8;
+#endif
+}
+
+/*
+ * set an 8bit value according to foreground/background color
+ */
+static inline void fill8_2col(u8 *dst, u8 fg, u8 bg, u32 mask)
+{
+       u32 fgm[2], bgm[2], tmp;
+
+       expand8_2col2mask(fg, bg, fgm, bgm);
+
+       mask |= mask << 8;
+#if BPL > 2
+       mask |= mask << 16;
+#endif
+       tmp = (mask & fgm[0]) ^ bgm[0];
+       dst[0] = tmp;
+       dst[2] = (tmp >>= 8);
+#if BPL > 2
+       dst[4] = (tmp >>= 8);
+       dst[6] = tmp >> 8;
+#endif
+#if BPL > 4
+       tmp = (mask & fgm[1]) ^ bgm[1];
+       dst[8] = tmp;
+       dst[10] = (tmp >>= 8);
+       dst[12] = (tmp >>= 8);
+       dst[14] = tmp >> 8;
+#endif
+}
+
+static const u32 two2word[] = {
+       0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff
+};
+
+static inline void expand16_col2mask(u8 c, u32 m[])
+{
+       m[0] = two2word[c & 3];
+#if BPL > 2
+       m[1] = two2word[(c >> 2) & 3];
+#endif
+#if BPL > 4
+       m[2] = two2word[(c >> 4) & 3];
+       m[3] = two2word[c >> 6];
+#endif
+}
+
+static inline void expand16_2col2mask(u8 fg, u8 bg, u32 fgm[], u32 bgm[])
+{
+       bgm[0] = two2word[bg & 3];
+       fgm[0] = two2word[fg & 3] ^ bgm[0];
+#if BPL > 2
+       bgm[1] = two2word[(bg >> 2) & 3];
+       fgm[1] = two2word[(fg >> 2) & 3] ^ bgm[1];
+#endif
+#if BPL > 4
+       bgm[2] = two2word[(bg >> 4) & 3];
+       fgm[2] = two2word[(fg >> 4) & 3] ^ bgm[2];
+       bgm[3] = two2word[bg >> 6];
+       fgm[3] = two2word[fg >> 6] ^ bgm[3];
+#endif
+}
+
+static inline u32 *fill16_col(u32 *dst, int rows, u32 m[])
+{
+       while (rows) {
+               *dst++ = m[0];
+#if BPL > 2
+               *dst++ = m[1];
+#endif
+#if BPL > 4
+               *dst++ = m[2];
+               *dst++ = m[3];
+#endif
+               rows--;
+       }
+       return dst;
+}
+
+static inline void memmove32_col(void *dst, void *src, u32 mask, u32 h, u32 bytes)
+{
+       u32 *s, *d, v;
+
+        s = src;
+        d = dst;
+        do {
+                v = (*s++ & mask) | (*d  & ~mask);
+                *d++ = v;
+#if BPL > 2
+                v = (*s++ & mask) | (*d  & ~mask);
+                *d++ = v;
+#endif
+#if BPL > 4
+                v = (*s++ & mask) | (*d  & ~mask);
+                *d++ = v;
+                v = (*s++ & mask) | (*d  & ~mask);
+                *d++ = v;
+#endif
+                d = (u32 *)((u8 *)d + bytes);
+                s = (u32 *)((u8 *)s + bytes);
+        } while (--h);
+}
+
+#endif
+
+#endif /* _VIDEO_ATAFB_UTILS_H */