drivers/video/atafb.c

   1 /*
   2  * linux/drivers/video/atafb.c -- Atari builtin chipset frame buffer device
   3  *
   4  *  Copyright (C) 1994 Martin Schaller & Roman Hodek
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  *
  10  * History:
  11  *   - 03 Jan 95: Original version by Martin Schaller: The TT driver and
  12  *                all the device independent stuff
  13  *   - 09 Jan 95: Roman: I've added the hardware abstraction (hw_switch)
  14  *                and wrote the Falcon, ST(E), and External drivers
  15  *                based on the original TT driver.
  16  *   - 07 May 95: Martin: Added colormap operations for the external driver
  17  *   - 21 May 95: Martin: Added support for overscan
  18  *                Andreas: some bug fixes for this
  19  *   -    Jul 95: Guenther Kelleter <guenther@pool.informatik.rwth-aachen.de>:
  20  *                Programmable Falcon video modes
  21  *                (thanks to Christian Cartus for documentation
  22  *                of VIDEL registers).
  23  *   - 27 Dec 95: Guenther: Implemented user definable video modes "user[0-7]"
  24  *                on minor 24...31. "user0" may be set on commandline by
  25  *                "R<x>;<y>;<depth>". (Makes sense only on Falcon)
  26  *                Video mode switch on Falcon now done at next VBL interrupt
  27  *                to avoid the annoying right shift of the screen.
  28  *   - 23 Sep 97: Juergen: added xres_virtual for cards like ProMST
  29  *                The external-part is legacy, therefore hardware-specific
  30  *                functions like panning/hardwarescrolling/blanking isn't
  31  *                                supported.
  32  *   - 29 Sep 97: Juergen: added Romans suggestion for pan_display
  33  *                                (var->xoffset was changed even if no set_screen_base avail.)
  34  *       - 05 Oct 97: Juergen: extfb (PACKED_PIXEL) is FB_PSEUDOCOLOR 'cause
  35  *                                we know how to set the colors
  36  *                                ext_*palette: read from ext_colors (former MV300_colors)
  37  *                                                          write to ext_colors and RAMDAC
  38  *
  39  * To do:
  40  *   - For the Falcon it is not possible to set random video modes on
  41  *     SM124 and SC/TV, only the bootup resolution is supported.
  42  *
  43  */
  44
  45 #define ATAFB_TT
  46 #define ATAFB_STE
  47 #define ATAFB_EXT
  48 #define ATAFB_FALCON
  49
  50 #include <linux/module.h>
  51 #include <linux/kernel.h>
  52 #include <linux/errno.h>
  53 #include <linux/string.h>
  54 #include <linux/mm.h>
  55 #include <linux/slab.h>
  56 #include <linux/delay.h>
  57 #include <linux/init.h>
  58 #include <linux/interrupt.h>
  59
  60 #include <asm/setup.h>
  61 #include <asm/uaccess.h>
  62 #include <asm/pgtable.h>
  63 #include <asm/irq.h>
  64 #include <asm/io.h>
  65
  66 #include <asm/atarihw.h>
  67 #include <asm/atariints.h>
  68 #include <asm/atari_stram.h>
  69
  70 #include <linux/fb.h>
  71 #include <asm/atarikb.h>
  72
  73 #include <video/fbcon.h>
  74 #include <video/fbcon-cfb8.h>
  75 #include <video/fbcon-cfb16.h>
  76 #include <video/fbcon-iplan2p2.h>
  77 #include <video/fbcon-iplan2p4.h>
  78 #include <video/fbcon-iplan2p8.h>
  79 #include <video/fbcon-mfb.h>
  80
  81
  82 #define SWITCH_ACIA 0x01                /* modes for switch on OverScan */
  83 #define SWITCH_SND6 0x40
  84 #define SWITCH_SND7 0x80
  85 #define SWITCH_NONE 0x00
  86
  87
  88 #define up(x, r) (((x) + (r) - 1) & ~((r)-1))
  89
  90
  91 static int default_par=0;       /* default resolution (0=none) */
  92
  93 static unsigned long default_mem_req=0;
  94
  95 static int hwscroll=-1;
  96
  97 static int use_hwscroll = 1;
  98
  99 static int sttt_xres=640,st_yres=400,tt_yres=480;
 100 static int sttt_xres_virtual=640,sttt_yres_virtual=400;
 101 static int ovsc_offset=0, ovsc_addlen=0;
 102
 103 static struct atafb_par {
 104         void *screen_base;
 105         int yres_virtual;
 106 #if defined ATAFB_TT || defined ATAFB_STE
 107         union {
 108                 struct {
 109                         int mode;
 110                         int sync;
 111                 } tt, st;
 112 #endif
 113 #ifdef ATAFB_FALCON
 114                 struct falcon_hw {
 115                         /* Here are fields for storing a video mode, as direct
 116                          * parameters for the hardware.
 117                          */
 118                         short sync;
 119                         short line_width;
 120                         short line_offset;
 121                         short st_shift;
 122                         short f_shift;
 123                         short vid_control;
 124                         short vid_mode;
 125                         short xoffset;
 126                         short hht, hbb, hbe, hdb, hde, hss;
 127                         short vft, vbb, vbe, vdb, vde, vss;
 128                         /* auxiliary information */
 129                         short mono;
 130                         short ste_mode;
 131                         short bpp;
 132                 } falcon;
 133 #endif
 134                 /* Nothing needed for external mode */
 135         } hw;
 136 } current_par;
 137
 138 /* Don't calculate an own resolution, and thus don't change the one found when
 139  * booting (currently used for the Falcon to keep settings for internal video
 140  * hardware extensions (e.g. ScreenBlaster)  */
 141 static int DontCalcRes = 0;
 142
 143 #ifdef ATAFB_FALCON
 144 #define HHT hw.falcon.hht
 145 #define HBB hw.falcon.hbb
 146 #define HBE hw.falcon.hbe
 147 #define HDB hw.falcon.hdb
 148 #define HDE hw.falcon.hde
 149 #define HSS hw.falcon.hss
 150 #define VFT hw.falcon.vft
 151 #define VBB hw.falcon.vbb
 152 #define VBE hw.falcon.vbe
 153 #define VDB hw.falcon.vdb
 154 #define VDE hw.falcon.vde
 155 #define VSS hw.falcon.vss
 156 #define VCO_CLOCK25             0x04
 157 #define VCO_CSYPOS              0x10
 158 #define VCO_VSYPOS              0x20
 159 #define VCO_HSYPOS              0x40
 160 #define VCO_SHORTOFFS   0x100
 161 #define VMO_DOUBLE              0x01
 162 #define VMO_INTER               0x02
 163 #define VMO_PREMASK             0x0c
 164 #endif
 165
 166 static struct fb_info fb_info;
 167
 168 static void *screen_base;       /* base address of screen */
 169 static void *real_screen_base;  /* (only for Overscan) */
 170
 171 static int screen_len;
 172
 173 static int current_par_valid=0;
 174
 175 static int mono_moni=0;
 176
 177 static struct display disp;
 178
 179
 180 #ifdef ATAFB_EXT
 181 /* external video handling */
 182
 183 static unsigned                 external_xres;
 184 static unsigned                 external_xres_virtual;
 185 static unsigned                 external_yres;
 186 /* not needed - atafb will never support panning/hardwarescroll with external
 187  * static unsigned              external_yres_virtual;
 188 */
 189
 190 static unsigned                 external_depth;
 191 static int                              external_pmode;
 192 static void *external_addr = 0;
 193 static unsigned long    external_len;
 194 static unsigned long    external_vgaiobase = 0;
 195 static unsigned int             external_bitspercol = 6;
 196
 197 /*
 198 JOE <joe@amber.dinoco.de>:
 199 added card type for external driver, is only needed for
 200 colormap handling.
 201 */
 202
 203 enum cardtype { IS_VGA, IS_MV300 };
 204 static enum cardtype external_card_type = IS_VGA;
 205
 206 /*
 207 The MV300 mixes the color registers. So we need an array of munged
 208 indices in order to access the correct reg.
 209 */
 210 static int MV300_reg_1bit[2]={0,1};
 211 static int MV300_reg_4bit[16]={
 212 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 };
 213 static int MV300_reg_8bit[256]={
 214 0, 128, 64, 192, 32, 160, 96, 224, 16, 144, 80, 208, 48, 176, 112, 240,
 215 8, 136, 72, 200, 40, 168, 104, 232, 24, 152, 88, 216, 56, 184, 120, 248,
 216 4, 132, 68, 196, 36, 164, 100, 228, 20, 148, 84, 212, 52, 180, 116, 244,
 217 12, 140, 76, 204, 44, 172, 108, 236, 28, 156, 92, 220, 60, 188, 124, 252,
 218 2, 130, 66, 194, 34, 162, 98, 226, 18, 146, 82, 210, 50, 178, 114, 242,
 219 10, 138, 74, 202, 42, 170, 106, 234, 26, 154, 90, 218, 58, 186, 122, 250,
 220 6, 134, 70, 198, 38, 166, 102, 230, 22, 150, 86, 214, 54, 182, 118, 246,
 221 14, 142, 78, 206, 46, 174, 110, 238, 30, 158, 94, 222, 62, 190, 126, 254,
 222 1, 129, 65, 193, 33, 161, 97, 225, 17, 145, 81, 209, 49, 177, 113, 241,
 223 9, 137, 73, 201, 41, 169, 105, 233, 25, 153, 89, 217, 57, 185, 121, 249,
 224 5, 133, 69, 197, 37, 165, 101, 229, 21, 149, 85, 213, 53, 181, 117, 245,
 225 13, 141, 77, 205, 45, 173, 109, 237, 29, 157, 93, 221, 61, 189, 125, 253,
 226 3, 131, 67, 195, 35, 163, 99, 227, 19, 147, 83, 211, 51, 179, 115, 243,
 227 11, 139, 75, 203, 43, 171, 107, 235, 27, 155, 91, 219, 59, 187, 123, 251,
 228 7, 135, 71, 199, 39, 167, 103, 231, 23, 151, 87, 215, 55, 183, 119, 247,
 229 15, 143, 79, 207, 47, 175, 111, 239, 31, 159, 95, 223, 63, 191, 127, 255 };
 230
 231 static int *MV300_reg = MV300_reg_8bit;
 232
 233 /*
 234 And on the MV300 it's difficult to read out the hardware palette. So we
 235 just keep track of the set colors in our own array here, and use that!
 236 */
 237
 238 static struct { unsigned char red,green,blue,pad; } ext_color[256];
 239 #endif /* ATAFB_EXT */
 240
 241
 242 static int inverse=0;
 243
 244 extern int fontheight_8x8;
 245 extern int fontwidth_8x8;
 246 extern unsigned char fontdata_8x8[];
 247
 248 extern int fontheight_8x16;
 249 extern int fontwidth_8x16;
 250 extern unsigned char fontdata_8x16[];
 251
 252 /* ++roman: This structure abstracts from the underlying hardware (ST(e),
 253  * TT, or Falcon.
 254  *
 255  * int (*detect)( void )
 256  *   This function should detect the current video mode settings and
 257  *   store them in atafb_predefined[0] for later reference by the
 258  *   user. Return the index+1 of an equivalent predefined mode or 0
 259  *   if there is no such.
 260  *
 261  * int (*encode_fix)( struct fb_fix_screeninfo *fix,
 262  *                    struct atafb_par *par )
 263  *   This function should fill in the 'fix' structure based on the
 264  *   values in the 'par' structure.
 265  *
 266  * int (*decode_var)( struct fb_var_screeninfo *var,
 267  *                    struct atafb_par *par )
 268  *   Get the video params out of 'var'. If a value doesn't fit, round
 269  *   it up, if it's too big, return EINVAL.
 270  *   Round up in the following order: bits_per_pixel, xres, yres,
 271  *   xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
 272  *   horizontal timing, vertical timing.
 273  *
 274  * int (*encode_var)( struct fb_var_screeninfo *var,
 275  *                    struct atafb_par *par );
 276  *   Fill the 'var' structure based on the values in 'par' and maybe
 277  *   other values read out of the hardware.
 278  *
 279  * void (*get_par)( struct atafb_par *par )
 280  *   Fill the hardware's 'par' structure.
 281  *
 282  * void (*set_par)( struct atafb_par *par )
 283  *   Set the hardware according to 'par'.
 284  *
 285  * int (*getcolreg)( unsigned regno, unsigned *red,
 286  *                   unsigned *green, unsigned *blue,
 287  *                   unsigned *transp, struct fb_info *info )
 288  *   Read a single color register and split it into
 289  *   colors/transparent. Return != 0 for invalid regno.
 290  *
 291  * void (*set_screen_base)(void *s_base)
 292  *   Set the base address of the displayed frame buffer. Only called
 293  *   if yres_virtual > yres or xres_virtual > xres.
 294  *
 295  * int (*blank)( int blank_mode )
 296  *   Blank the screen if blank_mode!=0, else unblank. If blank==NULL then
 297  *   the caller blanks by setting the CLUT to all black. Return 0 if blanking
 298  *   succeeded, !=0 if un-/blanking failed due to e.g. a video mode which
 299  *   doesn't support it. Implements VESA suspend and powerdown modes on
 300  *   hardware that supports disabling hsync/vsync:
 301  *       blank_mode==2: suspend vsync, 3:suspend hsync, 4: powerdown.
 302  */
 303
 304 static struct fb_hwswitch {
 305         int  (*detect)( void );
 306         int  (*encode_fix)( struct fb_fix_screeninfo *fix,
 307                                                 struct atafb_par *par );
 308         int  (*decode_var)( struct fb_var_screeninfo *var,
 309                                                 struct atafb_par *par );
 310         int  (*encode_var)( struct fb_var_screeninfo *var,
 311                                                 struct atafb_par *par );
 312         void (*get_par)( struct atafb_par *par );
 313         void (*set_par)( struct atafb_par *par );
 314         int  (*getcolreg)( unsigned regno, unsigned *red,
 315                                            unsigned *green, unsigned *blue,
 316                                            unsigned *transp, struct fb_info *info );
 317         void (*set_screen_base)(void *s_base);
 318         int  (*blank)( int blank_mode );
 319         int  (*pan_display)( struct fb_var_screeninfo *var,
 320                                                  struct atafb_par *par);
 321 } *fbhw;
 322
 323 static char *autodetect_names[] = {"autodetect", NULL};
 324 static char *stlow_names[] = {"stlow", NULL};
 325 static char *stmid_names[] = {"stmid", "default5", NULL};
 326 static char *sthigh_names[] = {"sthigh", "default4", NULL};
 327 static char *ttlow_names[] = {"ttlow", NULL};
 328 static char *ttmid_names[]= {"ttmid", "default1", NULL};
 329 static char *tthigh_names[]= {"tthigh", "default2", NULL};
 330 static char *vga2_names[] = {"vga2", NULL};
 331 static char *vga4_names[] = {"vga4", NULL};
 332 static char *vga16_names[] = {"vga16", "default3", NULL};
 333 static char *vga256_names[] = {"vga256", NULL};
 334 static char *falh2_names[] = {"falh2", NULL};
 335 static char *falh16_names[] = {"falh16", NULL};
 336
 337 static char **fb_var_names[] = {
 338         /* Writing the name arrays directly in this array (via "(char *[]){...}")
 339          * crashes gcc 2.5.8 (sigsegv) if the inner array
 340          * contains more than two items. I've also seen that all elements
 341          * were identical to the last (my cross-gcc) :-(*/
 342         autodetect_names,
 343         stlow_names,
 344         stmid_names,
 345         sthigh_names,
 346         ttlow_names,
 347         ttmid_names,
 348         tthigh_names,
 349         vga2_names,
 350         vga4_names,
 351         vga16_names,
 352         vga256_names,
 353         falh2_names,
 354         falh16_names,
 355         NULL
 356         /* ,NULL */ /* this causes a sigsegv on my gcc-2.5.8 */
 357 };
 358
 359 static struct fb_var_screeninfo atafb_predefined[] = {
 360         /*
 361          * yres_virtual==0 means use hw-scrolling if possible, else yres
 362          */
 363         { /* autodetect */
 364           0, 0, 0, 0, 0, 0, 0, 0,               /* xres-grayscale */
 365           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},   /* red green blue tran*/
 366           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 367         { /* st low */
 368           320, 200, 320, 0, 0, 0, 4, 0,
 369           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
 370           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 371         { /* st mid */
 372           640, 200, 640, 0, 0, 0, 2, 0,
 373           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
 374           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 375         { /* st high */
 376           640, 400, 640, 0, 0, 0, 1, 0,
 377           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
 378           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 379         { /* tt low */
 380           320, 480, 320, 0, 0, 0, 8, 0,
 381           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
 382           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 383         { /* tt mid */
 384           640, 480, 640, 0, 0, 0, 4, 0,
 385           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
 386           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 387         { /* tt high */
 388           1280, 960, 1280, 0, 0, 0, 1, 0,
 389           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
 390           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 391         { /* vga2 */
 392           640, 480, 640, 0, 0, 0, 1, 0,
 393           {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
 394           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 395         { /* vga4 */
 396           640, 480, 640, 0, 0, 0, 2, 0,
 397           {0, 4, 0}, {0, 4, 0}, {0, 4, 0}, {0, 0, 0},
 398           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 399         { /* vga16 */
 400           640, 480, 640, 0, 0, 0, 4, 0,
 401           {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
 402           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 403         { /* vga256 */
 404           640, 480, 640, 0, 0, 0, 8, 0,
 405           {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
 406           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 407         { /* falh2 */
 408           896, 608, 896, 0, 0, 0, 1, 0,
 409           {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
 410           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 411         { /* falh16 */
 412           896, 608, 896, 0, 0, 0, 4, 0,
 413           {0, 6, 0}, {0, 6, 0}, {0, 6, 0}, {0, 0, 0},
 414           0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0 },
 415 };
 416
 417 static int num_atafb_predefined=ARRAY_SIZE(atafb_predefined);
 418
 419
 420 static int
 421 get_video_mode(char *vname)
 422 {
 423     char ***name_list;
 424     char **name;
 425     int i;
 426     name_list=fb_var_names;
 427     for (i = 0 ; i < num_atafb_predefined ; i++) {
 428         name=*(name_list++);
 429         if (! name || ! *name)
 430             break;
 431         while (*name) {
 432             if (! strcmp(vname, *name))
 433                 return i+1;
 434             name++;
 435         }
 436     }
 437     return 0;
 438 }
 439
 440
 441
 442 /* ------------------- TT specific functions ---------------------- */
 443
 444 #ifdef ATAFB_TT
 445
 446 static int tt_encode_fix( struct fb_fix_screeninfo *fix,
 447                                                   struct atafb_par *par )
 448
 449 {
 450         int mode;
 451
 452         strcpy(fix->id,"Atari Builtin");
 453         fix->smem_start = (unsigned long)real_screen_base;
 454         fix->smem_len = screen_len;
 455         fix->type=FB_TYPE_INTERLEAVED_PLANES;
 456         fix->type_aux=2;
 457         fix->visual=FB_VISUAL_PSEUDOCOLOR;
 458         mode = par->hw.tt.mode & TT_SHIFTER_MODEMASK;
 459         if (mode == TT_SHIFTER_TTHIGH || mode == TT_SHIFTER_STHIGH) {
 460                 fix->type=FB_TYPE_PACKED_PIXELS;
 461                 fix->type_aux=0;
 462                 if (mode == TT_SHIFTER_TTHIGH)
 463                         fix->visual=FB_VISUAL_MONO01;
 464         }
 465         fix->xpanstep=0;
 466         fix->ypanstep=1;
 467         fix->ywrapstep=0;
 468         fix->line_length = 0;
 469         fix->accel = FB_ACCEL_ATARIBLITT;
 470         return 0;
 471 }
 472
 473
 474 static int tt_decode_var( struct fb_var_screeninfo *var,
 475                                                   struct atafb_par *par )
 476 {
 477         int xres=var->xres;
 478         int yres=var->yres;
 479         int bpp=var->bits_per_pixel;
 480         int linelen;
 481         int yres_virtual = var->yres_virtual;
 482
 483         if (mono_moni) {
 484                 if (bpp > 1 || xres > sttt_xres*2 || yres >tt_yres*2)
 485                         return -EINVAL;
 486                 par->hw.tt.mode=TT_SHIFTER_TTHIGH;
 487                 xres=sttt_xres*2;
 488                 yres=tt_yres*2;
 489                 bpp=1;
 490         } else {
 491                 if (bpp > 8 || xres > sttt_xres || yres > tt_yres)
 492                         return -EINVAL;
 493                 if (bpp > 4) {
 494                         if (xres > sttt_xres/2 || yres > tt_yres)
 495                                 return -EINVAL;
 496                         par->hw.tt.mode=TT_SHIFTER_TTLOW;
 497                         xres=sttt_xres/2;
 498                         yres=tt_yres;
 499                         bpp=8;
 500                 }
 501                 else if (bpp > 2) {
 502                         if (xres > sttt_xres || yres > tt_yres)
 503                                 return -EINVAL;
 504                         if (xres > sttt_xres/2 || yres > st_yres/2) {
 505                                 par->hw.tt.mode=TT_SHIFTER_TTMID;
 506                                 xres=sttt_xres;
 507                                 yres=tt_yres;
 508                                 bpp=4;
 509                         }
 510                         else {
 511                                 par->hw.tt.mode=TT_SHIFTER_STLOW;
 512                                 xres=sttt_xres/2;
 513                                 yres=st_yres/2;
 514                                 bpp=4;
 515                         }
 516                 }
 517                 else if (bpp > 1) {
 518                         if (xres > sttt_xres || yres > st_yres/2)
 519                                 return -EINVAL;
 520                         par->hw.tt.mode=TT_SHIFTER_STMID;
 521                         xres=sttt_xres;
 522                         yres=st_yres/2;
 523                         bpp=2;
 524                 }
 525                 else if (var->xres > sttt_xres || var->yres > st_yres) {
 526                         return -EINVAL;
 527                 }
 528                 else {
 529                         par->hw.tt.mode=TT_SHIFTER_STHIGH;
 530                         xres=sttt_xres;
 531                         yres=st_yres;
 532                         bpp=1;
 533                 }
 534         }
 535         if (yres_virtual <= 0)
 536                 yres_virtual = 0;
 537         else if (yres_virtual < yres)
 538                 yres_virtual = yres;
 539         if (var->sync & FB_SYNC_EXT)
 540                 par->hw.tt.sync=0;
 541         else
 542                 par->hw.tt.sync=1;
 543         linelen=xres*bpp/8;
 544         if (yres_virtual * linelen > screen_len && screen_len)
 545                 return -EINVAL;
 546         if (yres * linelen > screen_len && screen_len)
 547                 return -EINVAL;
 548         if (var->yoffset + yres > yres_virtual && yres_virtual)
 549                 return -EINVAL;
 550         par->yres_virtual = yres_virtual;
 551         par->screen_base = screen_base + var->yoffset * linelen;
 552         return 0;
 553 }
 554
 555 static int tt_encode_var( struct fb_var_screeninfo *var,
 556                                                   struct atafb_par *par )
 557 {
 558         int linelen;
 559         memset(var, 0, sizeof(struct fb_var_screeninfo));
 560         var->red.offset=0;
 561         var->red.length=4;
 562         var->red.msb_right=0;
 563         var->grayscale=0;
 564
 565         var->pixclock=31041;
 566         var->left_margin=120;           /* these may be incorrect       */
 567         var->right_margin=100;
 568         var->upper_margin=8;
 569         var->lower_margin=16;
 570         var->hsync_len=140;
 571         var->vsync_len=30;
 572
 573         var->height=-1;
 574         var->width=-1;
 575
 576         if (par->hw.tt.sync & 1)
 577                 var->sync=0;
 578         else
 579                 var->sync=FB_SYNC_EXT;
 580
 581         switch (par->hw.tt.mode & TT_SHIFTER_MODEMASK) {
 582         case TT_SHIFTER_STLOW:
 583                 var->xres=sttt_xres/2;
 584                 var->xres_virtual=sttt_xres_virtual/2;
 585                 var->yres=st_yres/2;
 586                 var->bits_per_pixel=4;
 587                 break;
 588         case TT_SHIFTER_STMID:
 589                 var->xres=sttt_xres;
 590                 var->xres_virtual=sttt_xres_virtual;
 591                 var->yres=st_yres/2;
 592                 var->bits_per_pixel=2;
 593                 break;
 594         case TT_SHIFTER_STHIGH:
 595                 var->xres=sttt_xres;
 596                 var->xres_virtual=sttt_xres_virtual;
 597                 var->yres=st_yres;
 598                 var->bits_per_pixel=1;
 599                 break;
 600         case TT_SHIFTER_TTLOW:
 601                 var->xres=sttt_xres/2;
 602                 var->xres_virtual=sttt_xres_virtual/2;
 603                 var->yres=tt_yres;
 604                 var->bits_per_pixel=8;
 605                 break;
 606         case TT_SHIFTER_TTMID:
 607                 var->xres=sttt_xres;
 608                 var->xres_virtual=sttt_xres_virtual;
 609                 var->yres=tt_yres;
 610                 var->bits_per_pixel=4;
 611                 break;
 612         case TT_SHIFTER_TTHIGH:
 613                 var->red.length=0;
 614                 var->xres=sttt_xres*2;
 615                 var->xres_virtual=sttt_xres_virtual*2;
 616                 var->yres=tt_yres*2;
 617                 var->bits_per_pixel=1;
 618                 break;
 619         }
 620         var->blue=var->green=var->red;
 621         var->transp.offset=0;
 622         var->transp.length=0;
 623         var->transp.msb_right=0;
 624         linelen=var->xres_virtual * var->bits_per_pixel / 8;
 625         if (! use_hwscroll)
 626                 var->yres_virtual=var->yres;
 627         else if (screen_len) {
 628                 if (par->yres_virtual)
 629                         var->yres_virtual = par->yres_virtual;
 630                 else
 631                         /* yres_virtual==0 means use maximum */
 632                         var->yres_virtual = screen_len / linelen;
 633         } else {
 634                 if (hwscroll < 0)
 635                         var->yres_virtual = 2 * var->yres;
 636                 else
 637                         var->yres_virtual=var->yres+hwscroll * 16;
 638         }
 639         var->xoffset=0;
 640         if (screen_base)
 641                 var->yoffset=(par->screen_base - screen_base)/linelen;
 642         else
 643                 var->yoffset=0;
 644         var->nonstd=0;
 645         var->activate=0;
 646         var->vmode=FB_VMODE_NONINTERLACED;
 647         return 0;
 648 }
 649
 650
 651 static void tt_get_par( struct atafb_par *par )
 652 {
 653         unsigned long addr;
 654         par->hw.tt.mode=shifter_tt.tt_shiftmode;
 655         par->hw.tt.sync=shifter.syncmode;
 656         addr = ((shifter.bas_hi & 0xff) << 16) |
 657                ((shifter.bas_md & 0xff) << 8)  |
 658                ((shifter.bas_lo & 0xff));
 659         par->screen_base = phys_to_virt(addr);
 660 }
 661
 662 static void tt_set_par( struct atafb_par *par )
 663 {
 664         shifter_tt.tt_shiftmode=par->hw.tt.mode;
 665         shifter.syncmode=par->hw.tt.sync;
 666         /* only set screen_base if really necessary */
 667         if (current_par.screen_base != par->screen_base)
 668                 fbhw->set_screen_base(par->screen_base);
 669 }
 670
 671
 672 static int tt_getcolreg(unsigned regno, unsigned *red,
 673                         unsigned *green, unsigned *blue,
 674                         unsigned *transp, struct fb_info *info)
 675 {
 676         int t, col;
 677
 678         if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) == TT_SHIFTER_STHIGH)
 679                 regno += 254;
 680         if (regno > 255)
 681                 return 1;
 682         t = tt_palette[regno];
 683         col = t & 15;
 684         col |= col << 4;
 685         col |= col << 8;
 686         *blue = col;
 687         col = (t >> 4) & 15;
 688         col |= col << 4;
 689         col |= col << 8;
 690         *green = col;
 691         col = (t >> 8) & 15;
 692         col |= col << 4;
 693         col |= col << 8;
 694         *red = col;
 695         *transp = 0;
 696         return 0;
 697 }
 698
 699
 700 static int tt_setcolreg(unsigned regno, unsigned red,
 701                         unsigned green, unsigned blue,
 702                         unsigned transp, struct fb_info *info)
 703 {
 704         if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) == TT_SHIFTER_STHIGH)
 705                 regno += 254;
 706         if (regno > 255)
 707                 return 1;
 708         tt_palette[regno] = (((red >> 12) << 8) | ((green >> 12) << 4) |
 709                              (blue >> 12));
 710         if ((shifter_tt.tt_shiftmode & TT_SHIFTER_MODEMASK) ==
 711                 TT_SHIFTER_STHIGH && regno == 254)
 712                 tt_palette[0] = 0;
 713         return 0;
 714 }
 715
 716
 717 static int tt_detect( void )
 718
 719 {       struct atafb_par par;
 720
 721         /* Determine the connected monitor: The DMA sound must be
 722          * disabled before reading the MFP GPIP, because the Sound
 723          * Done Signal and the Monochrome Detect are XORed together!
 724          *
 725          * Even on a TT, we should look if there is a DMA sound. It was
 726          * announced that the Eagle is TT compatible, but only the PCM is
 727          * missing...
 728          */
 729         if (ATARIHW_PRESENT(PCM_8BIT)) {
 730                 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
 731                 udelay(20);     /* wait a while for things to settle down */
 732         }
 733         mono_moni = (mfp.par_dt_reg & 0x80) == 0;
 734
 735         tt_get_par(&par);
 736         tt_encode_var(&atafb_predefined[0], &par);
 737
 738         return 1;
 739 }
 740
 741 #endif /* ATAFB_TT */
 742
 743 /* ------------------- Falcon specific functions ---------------------- */
 744
 745 #ifdef ATAFB_FALCON
 746
 747 static int mon_type;            /* Falcon connected monitor */
 748 static int f030_bus_width;      /* Falcon ram bus width (for vid_control) */
 749 #define F_MON_SM        0
 750 #define F_MON_SC        1
 751 #define F_MON_VGA       2
 752 #define F_MON_TV        3
 753
 754 static struct pixel_clock {
 755         unsigned long f;        /* f/[Hz] */
 756         unsigned long t;        /* t/[ps] (=1/f) */
 757         int right, hsync, left; /* standard timing in clock cycles, not pixel */
 758                 /* hsync initialized in falcon_detect() */
 759         int sync_mask;          /* or-mask for hw.falcon.sync to set this clock */
 760         int control_mask;       /* ditto, for hw.falcon.vid_control */
 761 }
 762 f25  = {25175000, 39721, 18, 0, 42, 0x0, VCO_CLOCK25},
 763 f32  = {32000000, 31250, 18, 0, 42, 0x0, 0},
 764 fext = {       0,     0, 18, 0, 42, 0x1, 0};
 765
 766 /* VIDEL-prescale values [mon_type][pixel_length from VCO] */
 767 static int vdl_prescale[4][3] = {{4,2,1}, {4,2,1}, {4,2,2}, {4,2,1}};
 768
 769 /* Default hsync timing [mon_type] in picoseconds */
 770 static long h_syncs[4] = {3000000, 4875000, 4000000, 4875000};
 771
 772 #ifdef FBCON_HAS_CFB16
 773 static u16 fbcon_cfb16_cmap[16];
 774 #endif
 775
 776 static inline int hxx_prescale(struct falcon_hw *hw)
 777 {
 778         return hw->ste_mode ? 16 :
 779                    vdl_prescale[mon_type][hw->vid_mode >> 2 & 0x3];
 780 }
 781
 782 static int falcon_encode_fix( struct fb_fix_screeninfo *fix,
 783                                                           struct atafb_par *par )
 784 {
 785         strcpy(fix->id, "Atari Builtin");
 786         fix->smem_start = (unsigned long)real_screen_base;
 787         fix->smem_len = screen_len;
 788         fix->type = FB_TYPE_INTERLEAVED_PLANES;
 789         fix->type_aux = 2;
 790         fix->visual = FB_VISUAL_PSEUDOCOLOR;
 791         fix->xpanstep = 1;
 792         fix->ypanstep = 1;
 793         fix->ywrapstep = 0;
 794         if (par->hw.falcon.mono) {
 795                 fix->type = FB_TYPE_PACKED_PIXELS;
 796                 fix->type_aux = 0;
 797                 /* no smooth scrolling with longword aligned video mem */
 798                 fix->xpanstep = 32;
 799         }
 800         else if (par->hw.falcon.f_shift & 0x100) {
 801                 fix->type = FB_TYPE_PACKED_PIXELS;
 802                 fix->type_aux = 0;
 803                 /* Is this ok or should it be DIRECTCOLOR? */
 804                 fix->visual = FB_VISUAL_TRUECOLOR;
 805                 fix->xpanstep = 2;
 806         }
 807         fix->line_length = 0;
 808         fix->accel = FB_ACCEL_ATARIBLITT;
 809         return 0;
 810 }
 811
 812
 813 static int falcon_decode_var( struct fb_var_screeninfo *var,
 814                                                           struct atafb_par *par )
 815 {
 816         int bpp = var->bits_per_pixel;
 817         int xres = var->xres;
 818         int yres = var->yres;
 819         int xres_virtual = var->xres_virtual;
 820         int yres_virtual = var->yres_virtual;
 821         int left_margin, right_margin, hsync_len;
 822         int upper_margin, lower_margin, vsync_len;
 823         int linelen;
 824         int interlace = 0, doubleline = 0;
 825         struct pixel_clock *pclock;
 826         int plen; /* width of pixel in clock cycles */
 827         int xstretch;
 828         int prescale;
 829         int longoffset = 0;
 830         int hfreq, vfreq;
 831
 832 /*
 833         Get the video params out of 'var'. If a value doesn't fit, round
 834         it up, if it's too big, return EINVAL.
 835         Round up in the following order: bits_per_pixel, xres, yres,
 836         xres_virtual, yres_virtual, xoffset, yoffset, grayscale, bitfields,
 837         horizontal timing, vertical timing.
 838
 839         There is a maximum of screen resolution determined by pixelclock
 840         and minimum frame rate -- (X+hmarg.)*(Y+vmarg.)*vfmin <= pixelclock.
 841         In interlace mode this is     "     *    "     *vfmin <= pixelclock.
 842         Additional constraints: hfreq.
 843         Frequency range for multisync monitors is given via command line.
 844         For TV and SM124 both frequencies are fixed.
 845
 846         X % 16 == 0 to fit 8x?? font (except 1 bitplane modes must use X%32==0)
 847         Y % 16 == 0 to fit 8x16 font
 848         Y % 8 == 0 if Y<400
 849
 850         Currently interlace and doubleline mode in var are ignored.
 851         On SM124 and TV only the standard resolutions can be used.
 852 */
 853
 854         /* Reject uninitialized mode */
 855         if (!xres || !yres || !bpp)
 856                 return -EINVAL;
 857
 858         if (mon_type == F_MON_SM && bpp != 1) {
 859                 return -EINVAL;
 860         }
 861         else if (bpp <= 1) {
 862                 bpp = 1;
 863                 par->hw.falcon.f_shift = 0x400;
 864                 par->hw.falcon.st_shift = 0x200;
 865         }
 866         else if (bpp <= 2) {
 867                 bpp = 2;
 868                 par->hw.falcon.f_shift = 0x000;
 869                 par->hw.falcon.st_shift = 0x100;
 870         }
 871         else if (bpp <= 4) {
 872                 bpp = 4;
 873                 par->hw.falcon.f_shift = 0x000;
 874                 par->hw.falcon.st_shift = 0x000;
 875         }
 876         else if (bpp <= 8) {
 877                 bpp = 8;
 878                 par->hw.falcon.f_shift = 0x010;
 879         }
 880         else if (bpp <= 16) {
 881                 bpp = 16; /* packed pixel mode */
 882                 par->hw.falcon.f_shift = 0x100; /* hicolor, no overlay */
 883         }
 884         else
 885                 return -EINVAL;
 886         par->hw.falcon.bpp = bpp;
 887
 888         if (mon_type == F_MON_SM || DontCalcRes) {
 889                 /* Skip all calculations. VGA/TV/SC1224 only supported. */
 890                 struct fb_var_screeninfo *myvar = &atafb_predefined[0];
 891
 892                 if (bpp > myvar->bits_per_pixel ||
 893                         var->xres > myvar->xres ||
 894                         var->yres > myvar->yres)
 895                         return -EINVAL;
 896                 fbhw->get_par(par);     /* Current par will be new par */
 897                 goto set_screen_base;   /* Don't forget this */
 898         }
 899
 900         /* Only some fixed resolutions < 640x400 */
 901         if (xres <= 320)
 902                 xres = 320;
 903         else if (xres <= 640 && bpp != 16)
 904                 xres = 640;
 905         if (yres <= 200)
 906                 yres = 200;
 907         else if (yres <= 240)
 908                 yres = 240;
 909         else if (yres <= 400)
 910                 yres = 400;
 911
 912         /* 2 planes must use STE compatibility mode */
 913         par->hw.falcon.ste_mode = bpp==2;
 914         par->hw.falcon.mono = bpp==1;
 915
 916         /* Total and visible scanline length must be a multiple of one longword,
 917          * this and the console fontwidth yields the alignment for xres and
 918          * xres_virtual.
 919          * TODO: this way "odd" fontheights are not supported
 920          *
 921          * Special case in STE mode: blank and graphic positions don't align,
 922          * avoid trash at right margin
 923          */
 924         if (par->hw.falcon.ste_mode)
 925                 xres = (xres + 63) & ~63;
 926         else if (bpp == 1)
 927                 xres = (xres + 31) & ~31;
 928         else
 929                 xres = (xres + 15) & ~15;
 930         if (yres >= 400)
 931                 yres = (yres + 15) & ~15;
 932         else
 933                 yres = (yres + 7) & ~7;
 934
 935         if (xres_virtual < xres)
 936                 xres_virtual = xres;
 937         else if (bpp == 1)
 938                 xres_virtual = (xres_virtual + 31) & ~31;
 939         else
 940                 xres_virtual = (xres_virtual + 15) & ~15;
 941
 942         if (yres_virtual <= 0)
 943                 yres_virtual = 0;
 944         else if (yres_virtual < yres)
 945                 yres_virtual = yres;
 946
 947         /* backward bug-compatibility */
 948         if (var->pixclock > 1)
 949                 var->pixclock -= 1;
 950
 951         par->hw.falcon.line_width = bpp * xres / 16;
 952         par->hw.falcon.line_offset = bpp * (xres_virtual - xres) / 16;
 953
 954         /* single or double pixel width */
 955         xstretch = (xres < 640) ? 2 : 1;
 956
 957 #if 0 /* SM124 supports only 640x400, this is rejected above */
 958         if (mon_type == F_MON_SM) {
 959                 if (xres != 640 && yres != 400)
 960                         return -EINVAL;
 961                 plen = 1;
 962                 pclock = &f32;
 963                 /* SM124-mode is special */
 964                 par->hw.falcon.ste_mode = 1;
 965                 par->hw.falcon.f_shift = 0x000;
 966                 par->hw.falcon.st_shift = 0x200;
 967                 left_margin = hsync_len = 128 / plen;
 968                 right_margin = 0;
 969                 /* TODO set all margins */
 970         }
 971         else
 972 #endif
 973         if (mon_type == F_MON_SC || mon_type == F_MON_TV) {
 974                 plen = 2 * xstretch;
 975                 if (var->pixclock > f32.t * plen)
 976                         return -EINVAL;
 977                 pclock = &f32;
 978                 if (yres > 240)
 979                         interlace = 1;
 980                 if (var->pixclock == 0) {
 981                         /* set some minimal margins which center the screen */
 982                         left_margin = 32;
 983                         right_margin = 18;
 984                         hsync_len = pclock->hsync / plen;
 985                         upper_margin = 31;
 986                         lower_margin = 14;
 987                         vsync_len = interlace ? 3 : 4;
 988                 } else {
 989                         left_margin = var->left_margin;
 990                         right_margin = var->right_margin;
 991                         hsync_len = var->hsync_len;
 992                         upper_margin = var->upper_margin;
 993                         lower_margin = var->lower_margin;
 994                         vsync_len = var->vsync_len;
 995                         if (var->vmode & FB_VMODE_INTERLACED) {
 996                                 upper_margin = (upper_margin + 1) / 2;
 997                                 lower_margin = (lower_margin + 1) / 2;
 998                                 vsync_len = (vsync_len + 1) / 2;
 999                         } else if (var->vmode & FB_VMODE_DOUBLE) {
1000                                 upper_margin *= 2;
1001                                 lower_margin *= 2;
1002                                 vsync_len *= 2;
1003                         }
1004                 }
1005         }
1006         else
1007         {       /* F_MON_VGA */
1008                 if (bpp == 16)
1009                         xstretch = 2; /* Double pixel width only for hicolor */
1010                 /* Default values are used for vert./hor. timing if no pixelclock given. */
1011                 if (var->pixclock == 0) {
1012                         int linesize;
1013
1014                         /* Choose master pixelclock depending on hor. timing */
1015                         plen = 1 * xstretch;
1016                         if ((plen * xres + f25.right+f25.hsync+f25.left) *
1017                             fb_info.monspecs.hfmin < f25.f)
1018                                 pclock = &f25;
1019                         else if ((plen * xres + f32.right+f32.hsync+f32.left) *
1020                             fb_info.monspecs.hfmin < f32.f)
1021                                 pclock = &f32;
1022                         else if ((plen * xres + fext.right+fext.hsync+fext.left) *
1023                             fb_info.monspecs.hfmin < fext.f
1024                                  && fext.f)
1025                                 pclock = &fext;
1026                         else
1027                                 return -EINVAL;
1028
1029                         left_margin = pclock->left / plen;
1030                         right_margin = pclock->right / plen;
1031                         hsync_len = pclock->hsync / plen;
1032                         linesize = left_margin + xres + right_margin + hsync_len;
1033                         upper_margin = 31;
1034                         lower_margin = 11;
1035                         vsync_len = 3;
1036                 }
1037                 else {
1038                         /* Choose largest pixelclock <= wanted clock */
1039                         int i;
1040                         unsigned long pcl = ULONG_MAX;
1041                         pclock = 0;
1042                         for (i=1; i <= 4; i *= 2) {
1043                                 if (f25.t*i >= var->pixclock && f25.t*i < pcl) {
1044                                         pcl = f25.t * i;
1045                                         pclock = &f25;
1046                                 }
1047                                 if (f32.t*i >= var->pixclock && f32.t*i < pcl) {
1048                                         pcl = f32.t * i;
1049                                         pclock = &f32;
1050                                 }
1051                                 if (fext.t && fext.t*i >= var->pixclock && fext.t*i < pcl) {
1052                                         pcl = fext.t * i;
1053                                         pclock = &fext;
1054                                 }
1055                         }
1056                         if (!pclock)
1057                                 return -EINVAL;
1058                         plen = pcl / pclock->t;
1059
1060                         left_margin = var->left_margin;
1061                         right_margin = var->right_margin;
1062                         hsync_len = var->hsync_len;
1063                         upper_margin = var->upper_margin;
1064                         lower_margin = var->lower_margin;
1065                         vsync_len = var->vsync_len;
1066                         /* Internal unit is [single lines per (half-)frame] */
1067                         if (var->vmode & FB_VMODE_INTERLACED) {
1068                                 /* # lines in half frame */
1069                                 /* External unit is [lines per full frame] */
1070                                 upper_margin = (upper_margin + 1) / 2;
1071                                 lower_margin = (lower_margin + 1) / 2;
1072                                 vsync_len = (vsync_len + 1) / 2;
1073                         }
1074                         else if (var->vmode & FB_VMODE_DOUBLE) {
1075                                 /* External unit is [double lines per frame] */
1076                                 upper_margin *= 2;
1077                                 lower_margin *= 2;
1078                                 vsync_len *= 2;
1079                         }
1080                 }
1081                 if (pclock == &fext)
1082                         longoffset = 1; /* VIDEL doesn't synchronize on short offset */
1083         }
1084         /* Is video bus bandwidth (32MB/s) too low for this resolution? */
1085         /* this is definitely wrong if bus clock != 32MHz */
1086         if (pclock->f / plen / 8 * bpp > 32000000L)
1087                 return -EINVAL;
1088
1089         if (vsync_len < 1)
1090                 vsync_len = 1;
1091
1092         /* include sync lengths in right/lower margin for all calculations */
1093         right_margin += hsync_len;
1094         lower_margin += vsync_len;
1095
1096         /* ! In all calculations of margins we use # of lines in half frame
1097          * (which is a full frame in non-interlace mode), so we can switch
1098          * between interlace and non-interlace without messing around
1099          * with these.
1100          */
1101   again:
1102         /* Set base_offset 128 and video bus width */
1103         par->hw.falcon.vid_control = mon_type | f030_bus_width;
1104         if (!longoffset)
1105                 par->hw.falcon.vid_control |= VCO_SHORTOFFS;    /* base_offset 64 */
1106         if (var->sync & FB_SYNC_HOR_HIGH_ACT)
1107                 par->hw.falcon.vid_control |= VCO_HSYPOS;
1108         if (var->sync & FB_SYNC_VERT_HIGH_ACT)
1109                 par->hw.falcon.vid_control |= VCO_VSYPOS;
1110         /* Pixelclock */
1111         par->hw.falcon.vid_control |= pclock->control_mask;
1112         /* External or internal clock */
1113         par->hw.falcon.sync = pclock->sync_mask | 0x2;
1114         /* Pixellength and prescale */
1115         par->hw.falcon.vid_mode = (2/plen) << 2;
1116         if (doubleline)
1117                 par->hw.falcon.vid_mode |= VMO_DOUBLE;
1118         if (interlace)
1119                 par->hw.falcon.vid_mode |= VMO_INTER;
1120
1121         /*********************
1122         Horizontal timing: unit = [master clock cycles]
1123         unit of hxx-registers: [master clock cycles * prescale]
1124         Hxx-registers are 9 bit wide
1125
1126         1 line = ((hht + 2) * 2 * prescale) clock cycles
1127
1128         graphic output = hdb & 0x200 ?
1129                ((hht+2)*2 - hdb + hde) * prescale - hdboff + hdeoff:
1130                ( hht + 2  - hdb + hde) * prescale - hdboff + hdeoff
1131         (this must be a multiple of plen*128/bpp, on VGA pixels
1132          to the right may be cut off with a bigger right margin)
1133
1134         start of graphics relative to start of 1st halfline = hdb & 0x200 ?
1135                (hdb - hht - 2) * prescale + hdboff :
1136                hdb * prescale + hdboff
1137
1138         end of graphics relative to start of 1st halfline =
1139                (hde + hht + 2) * prescale + hdeoff
1140         *********************/
1141         /* Calculate VIDEL registers */
1142         {
1143         int hdb_off, hde_off, base_off;
1144         int gstart, gend1, gend2, align;
1145
1146         prescale = hxx_prescale(&par->hw.falcon);
1147         base_off = par->hw.falcon.vid_control & VCO_SHORTOFFS ? 64 : 128;
1148
1149         /* Offsets depend on video mode */
1150         /* Offsets are in clock cycles, divide by prescale to
1151          * calculate hd[be]-registers
1152          */
1153         if (par->hw.falcon.f_shift & 0x100) {
1154                 align = 1;
1155                 hde_off = 0;
1156                 hdb_off = (base_off + 16 * plen) + prescale;
1157         }
1158         else {
1159                 align = 128 / bpp;
1160                 hde_off = ((128 / bpp + 2) * plen);
1161                 if (par->hw.falcon.ste_mode)
1162                         hdb_off = (64 + base_off + (128 / bpp + 2) * plen) + prescale;
1163                 else
1164                         hdb_off = (base_off + (128 / bpp + 18) * plen) + prescale;
1165         }
1166
1167         gstart = (prescale/2 + plen * left_margin) / prescale;
1168         /* gend1 is for hde (gend-gstart multiple of align), shifter's xres */
1169         gend1 = gstart + ((xres + align-1) / align)*align * plen / prescale;
1170         /* gend2 is for hbb, visible xres (rest to gend1 is cut off by hblank) */
1171         gend2 = gstart + xres * plen / prescale;
1172         par->HHT = plen * (left_margin + xres + right_margin) /
1173                            (2 * prescale) - 2;
1174 /*      par->HHT = (gend2 + plen * right_margin / prescale) / 2 - 2;*/
1175
1176         par->HDB = gstart - hdb_off/prescale;
1177         par->HBE = gstart;
1178         if (par->HDB < 0) par->HDB += par->HHT + 2 + 0x200;
1179         par->HDE = gend1 - par->HHT - 2 - hde_off/prescale;
1180         par->HBB = gend2 - par->HHT - 2;
1181 #if 0
1182         /* One more Videl constraint: data fetch of two lines must not overlap */
1183         if ((par->HDB & 0x200)  &&  (par->HDB & ~0x200) - par->HDE <= 5) {
1184                 /* if this happens increase margins, decrease hfreq. */
1185         }
1186 #endif
1187         if (hde_off % prescale)
1188                 par->HBB++;             /* compensate for non matching hde and hbb */
1189         par->HSS = par->HHT + 2 - plen * hsync_len / prescale;
1190         if (par->HSS < par->HBB)
1191                 par->HSS = par->HBB;
1192         }
1193
1194         /*  check hor. frequency */
1195         hfreq = pclock->f / ((par->HHT+2)*prescale*2);
1196         if (hfreq > fb_info.monspecs.hfmax && mon_type!=F_MON_VGA) {
1197                 /* ++guenther:   ^^^^^^^^^^^^^^^^^^^ can't remember why I did this */
1198                 /* Too high -> enlarge margin */
1199                 left_margin += 1;
1200                 right_margin += 1;
1201                 goto again;
1202         }
1203         if (hfreq > fb_info.monspecs.hfmax || hfreq < fb_info.monspecs.hfmin)
1204                 return -EINVAL;
1205
1206         /* Vxx-registers */
1207         /* All Vxx must be odd in non-interlace, since frame starts in the middle
1208          * of the first displayed line!
1209          * One frame consists of VFT+1 half lines. VFT+1 must be even in
1210          * non-interlace, odd in interlace mode for synchronisation.
1211          * Vxx-registers are 11 bit wide
1212          */
1213         par->VBE = (upper_margin * 2 + 1); /* must begin on odd halfline */
1214         par->VDB = par->VBE;
1215         par->VDE = yres;
1216         if (!interlace) par->VDE <<= 1;
1217         if (doubleline) par->VDE <<= 1;  /* VDE now half lines per (half-)frame */
1218         par->VDE += par->VDB;
1219         par->VBB = par->VDE;
1220         par->VFT = par->VBB + (lower_margin * 2 - 1) - 1;
1221         par->VSS = par->VFT+1 - (vsync_len * 2 - 1);
1222         /* vbb,vss,vft must be even in interlace mode */
1223         if (interlace) {
1224                 par->VBB++;
1225                 par->VSS++;
1226                 par->VFT++;
1227         }
1228
1229         /* V-frequency check, hope I didn't create any loop here. */
1230         /* Interlace and doubleline are mutually exclusive. */
1231         vfreq = (hfreq * 2) / (par->VFT + 1);
1232         if      (vfreq > fb_info.monspecs.vfmax && !doubleline && !interlace) {
1233                 /* Too high -> try again with doubleline */
1234                 doubleline = 1;
1235                 goto again;
1236         }
1237         else if (vfreq < fb_info.monspecs.vfmin && !interlace && !doubleline) {
1238                 /* Too low -> try again with interlace */
1239                 interlace = 1;
1240                 goto again;
1241         }
1242         else if (vfreq < fb_info.monspecs.vfmin && doubleline) {
1243                 /* Doubleline too low -> clear doubleline and enlarge margins */
1244                 int lines;
1245                 doubleline = 0;
1246                 for (lines=0;
1247                      (hfreq*2)/(par->VFT+1+4*lines-2*yres)>fb_info.monspecs.vfmax;
1248                      lines++)
1249                         ;
1250                 upper_margin += lines;
1251                 lower_margin += lines;
1252                 goto again;
1253         }
1254         else if (vfreq > fb_info.monspecs.vfmax && doubleline) {
1255                 /* Doubleline too high -> enlarge margins */
1256                 int lines;
1257                 for (lines=0;
1258                      (hfreq*2)/(par->VFT+1+4*lines)>fb_info.monspecs.vfmax;
1259                      lines+=2)
1260                         ;
1261                 upper_margin += lines;
1262                 lower_margin += lines;
1263                 goto again;
1264         }
1265         else if (vfreq > fb_info.monspecs.vfmax && interlace) {
1266                 /* Interlace, too high -> enlarge margins */
1267                 int lines;
1268                 for (lines=0;
1269                      (hfreq*2)/(par->VFT+1+4*lines)>fb_info.monspecs.vfmax;
1270                      lines++)
1271                         ;
1272                 upper_margin += lines;
1273                 lower_margin += lines;
1274                 goto again;
1275         }
1276         else if (vfreq < fb_info.monspecs.vfmin ||
1277                  vfreq > fb_info.monspecs.vfmax)
1278                 return -EINVAL;
1279
1280   set_screen_base:
1281         linelen = xres_virtual * bpp / 8;
1282         if (yres_virtual * linelen > screen_len && screen_len)
1283                 return -EINVAL;
1284         if (yres * linelen > screen_len && screen_len)
1285                 return -EINVAL;
1286         if (var->yoffset + yres > yres_virtual && yres_virtual)
1287                 return -EINVAL;
1288         par->yres_virtual = yres_virtual;
1289         par->screen_base = screen_base + var->yoffset * linelen;
1290         par->hw.falcon.xoffset = 0;
1291
1292         return 0;
1293 }
1294
1295 static int falcon_encode_var( struct fb_var_screeninfo *var,
1296                                                           struct atafb_par *par )
1297 {
1298 /* !!! only for VGA !!! */
1299         int linelen;
1300         int prescale, plen;
1301         int hdb_off, hde_off, base_off;
1302         struct falcon_hw *hw = &par->hw.falcon;
1303
1304         memset(var, 0, sizeof(struct fb_var_screeninfo));
1305         /* possible frequencies: 25.175 or 32MHz */
1306         var->pixclock = hw->sync & 0x1 ? fext.t :
1307                         hw->vid_control & VCO_CLOCK25 ? f25.t : f32.t;
1308
1309         var->height=-1;
1310         var->width=-1;
1311
1312         var->sync=0;
1313         if (hw->vid_control & VCO_HSYPOS)
1314                 var->sync |= FB_SYNC_HOR_HIGH_ACT;
1315         if (hw->vid_control & VCO_VSYPOS)
1316                 var->sync |= FB_SYNC_VERT_HIGH_ACT;
1317
1318         var->vmode = FB_VMODE_NONINTERLACED;
1319         if (hw->vid_mode & VMO_INTER)
1320                 var->vmode |= FB_VMODE_INTERLACED;
1321         if (hw->vid_mode & VMO_DOUBLE)
1322                 var->vmode |= FB_VMODE_DOUBLE;
1323
1324         /* visible y resolution:
1325          * Graphics display starts at line VDB and ends at line
1326          * VDE. If interlace mode off unit of VC-registers is
1327          * half lines, else lines.
1328          */
1329         var->yres = hw->vde - hw->vdb;
1330         if (!(var->vmode & FB_VMODE_INTERLACED))
1331                 var->yres >>= 1;
1332         if (var->vmode & FB_VMODE_DOUBLE)
1333                 var->yres >>= 1;
1334
1335         /* to get bpp, we must examine f_shift and st_shift.
1336          * f_shift is valid if any of bits no. 10, 8 or 4
1337          * is set. Priority in f_shift is: 10 ">" 8 ">" 4, i.e.
1338          * if bit 10 set then bit 8 and bit 4 don't care...
1339          * If all these bits are 0 get display depth from st_shift
1340          * (as for ST and STE)
1341          */
1342         if (hw->f_shift & 0x400)                /* 2 colors */
1343                 var->bits_per_pixel = 1;
1344         else if (hw->f_shift & 0x100)   /* hicolor */
1345                 var->bits_per_pixel = 16;
1346         else if (hw->f_shift & 0x010)   /* 8 bitplanes */
1347                 var->bits_per_pixel = 8;
1348         else if (hw->st_shift == 0)
1349                 var->bits_per_pixel = 4;
1350         else if (hw->st_shift == 0x100)
1351                 var->bits_per_pixel = 2;
1352         else /* if (hw->st_shift == 0x200) */
1353                 var->bits_per_pixel = 1;
1354
1355         var->xres = hw->line_width * 16 / var->bits_per_pixel;
1356         var->xres_virtual = var->xres + hw->line_offset * 16 / var->bits_per_pixel;
1357         if (hw->xoffset)
1358                 var->xres_virtual += 16;
1359
1360         if (var->bits_per_pixel == 16) {
1361                 var->red.offset=11;
1362                 var->red.length=5;
1363                 var->red.msb_right=0;
1364                 var->green.offset=5;
1365                 var->green.length=6;
1366                 var->green.msb_right=0;
1367                 var->blue.offset=0;
1368                 var->blue.length=5;
1369                 var->blue.msb_right=0;
1370         }
1371         else {
1372                 var->red.offset=0;
1373                 var->red.length = hw->ste_mode ? 4 : 6;
1374                 var->red.msb_right=0;
1375                 var->grayscale=0;
1376                 var->blue=var->green=var->red;
1377         }
1378         var->transp.offset=0;
1379         var->transp.length=0;
1380         var->transp.msb_right=0;
1381
1382         linelen = var->xres_virtual * var->bits_per_pixel / 8;
1383         if (screen_len) {
1384                 if (par->yres_virtual)
1385                         var->yres_virtual = par->yres_virtual;
1386                 else
1387                         /* yres_virtual==0 means use maximum */
1388                         var->yres_virtual = screen_len / linelen;
1389         }
1390         else {
1391                 if (hwscroll < 0)
1392                         var->yres_virtual = 2 * var->yres;
1393                 else
1394                         var->yres_virtual=var->yres+hwscroll * 16;
1395         }
1396         var->xoffset=0; /* TODO change this */
1397
1398         /* hdX-offsets */
1399         prescale = hxx_prescale(hw);
1400         plen = 4 >> (hw->vid_mode >> 2 & 0x3);
1401         base_off = hw->vid_control & VCO_SHORTOFFS ? 64 : 128;
1402         if (hw->f_shift & 0x100) {
1403                 hde_off = 0;
1404                 hdb_off = (base_off + 16 * plen) + prescale;
1405         }
1406         else {
1407                 hde_off = ((128 / var->bits_per_pixel + 2) * plen);
1408                 if (hw->ste_mode)
1409                         hdb_off = (64 + base_off + (128 / var->bits_per_pixel + 2) * plen)
1410                                          + prescale;
1411                 else
1412                         hdb_off = (base_off + (128 / var->bits_per_pixel + 18) * plen)
1413                                          + prescale;
1414         }
1415
1416         /* Right margin includes hsync */
1417         var->left_margin = hdb_off + prescale * ((hw->hdb & 0x1ff) -
1418                                            (hw->hdb & 0x200 ? 2+hw->hht : 0));
1419         if (hw->ste_mode || mon_type!=F_MON_VGA)
1420                 var->right_margin = prescale * (hw->hht + 2 - hw->hde) - hde_off;
1421         else
1422                 /* can't use this in ste_mode, because hbb is +1 off */
1423                 var->right_margin = prescale * (hw->hht + 2 - hw->hbb);
1424         var->hsync_len = prescale * (hw->hht + 2 - hw->hss);
1425
1426         /* Lower margin includes vsync */
1427         var->upper_margin = hw->vdb / 2 ;  /* round down to full lines */
1428         var->lower_margin = (hw->vft+1 - hw->vde + 1) / 2; /* round up */
1429         var->vsync_len    = (hw->vft+1 - hw->vss + 1) / 2; /* round up */
1430         if (var->vmode & FB_VMODE_INTERLACED) {
1431                 var->upper_margin *= 2;
1432                 var->lower_margin *= 2;
1433                 var->vsync_len *= 2;
1434         }
1435         else if (var->vmode & FB_VMODE_DOUBLE) {
1436                 var->upper_margin = (var->upper_margin + 1) / 2;
1437                 var->lower_margin = (var->lower_margin + 1) / 2;
1438                 var->vsync_len = (var->vsync_len + 1) / 2;
1439         }
1440
1441         var->pixclock *= plen;
1442         var->left_margin /= plen;
1443         var->right_margin /= plen;
1444         var->hsync_len /= plen;
1445
1446         var->right_margin -= var->hsync_len;
1447         var->lower_margin -= var->vsync_len;
1448
1449         if (screen_base)
1450                 var->yoffset=(par->screen_base - screen_base)/linelen;
1451         else
1452                 var->yoffset=0;
1453         var->nonstd=0;  /* what is this for? */
1454         var->activate=0;
1455         return 0;
1456 }
1457
1458
1459 static int f_change_mode = 0;
1460 static struct falcon_hw f_new_mode;
1461 static int f_pan_display = 0;
1462
1463 static void falcon_get_par( struct atafb_par *par )
1464 {
1465         unsigned long addr;
1466         struct falcon_hw *hw = &par->hw.falcon;
1467
1468         hw->line_width = shifter_f030.scn_width;
1469         hw->line_offset = shifter_f030.off_next;
1470         hw->st_shift = videl.st_shift & 0x300;
1471         hw->f_shift = videl.f_shift;
1472         hw->vid_control = videl.control;
1473         hw->vid_mode = videl.mode;
1474         hw->sync = shifter.syncmode & 0x1;
1475         hw->xoffset = videl.xoffset & 0xf;
1476         hw->hht = videl.hht;
1477         hw->hbb = videl.hbb;
1478         hw->hbe = videl.hbe;
1479         hw->hdb = videl.hdb;
1480         hw->hde = videl.hde;
1481         hw->hss = videl.hss;
1482         hw->vft = videl.vft;
1483         hw->vbb = videl.vbb;
1484         hw->vbe = videl.vbe;
1485         hw->vdb = videl.vdb;
1486         hw->vde = videl.vde;
1487         hw->vss = videl.vss;
1488
1489         addr = (shifter.bas_hi & 0xff) << 16 |
1490                (shifter.bas_md & 0xff) << 8  |
1491                (shifter.bas_lo & 0xff);
1492         par->screen_base = phys_to_virt(addr);
1493
1494         /* derived parameters */
1495         hw->ste_mode = (hw->f_shift & 0x510)==0 && hw->st_shift==0x100;
1496         hw->mono = (hw->f_shift & 0x400) ||
1497                    ((hw->f_shift & 0x510)==0 && hw->st_shift==0x200);
1498 }
1499
1500 static void falcon_set_par( struct atafb_par *par )
1501 {
1502         f_change_mode = 0;
1503
1504         /* only set screen_base if really necessary */
1505         if (current_par.screen_base != par->screen_base)
1506                 fbhw->set_screen_base(par->screen_base);
1507
1508         /* Don't touch any other registers if we keep the default resolution */
1509         if (DontCalcRes)
1510                 return;
1511
1512         /* Tell vbl-handler to change video mode.
1513          * We change modes only on next VBL, to avoid desynchronisation
1514          * (a shift to the right and wrap around by a random number of pixels
1515          * in all monochrome modes).
1516          * This seems to work on my Falcon.
1517          */
1518         f_new_mode = par->hw.falcon;
1519         f_change_mode = 1;
1520 }
1521
1522
1523 static irqreturn_t falcon_vbl_switcher( int irq, void *dummy )
1524 {
1525         struct falcon_hw *hw = &f_new_mode;
1526
1527         if (f_change_mode) {
1528                 f_change_mode = 0;
1529
1530                 if (hw->sync & 0x1) {
1531                         /* Enable external pixelclock. This code only for ScreenWonder */
1532                         *(volatile unsigned short*)0xffff9202 = 0xffbf;
1533                 }
1534                 else {
1535                         /* Turn off external clocks. Read sets all output bits to 1. */
1536                         *(volatile unsigned short*)0xffff9202;
1537                 }
1538                 shifter.syncmode = hw->sync;
1539
1540                 videl.hht = hw->hht;
1541                 videl.hbb = hw->hbb;
1542                 videl.hbe = hw->hbe;
1543                 videl.hdb = hw->hdb;
1544                 videl.hde = hw->hde;
1545                 videl.hss = hw->hss;
1546                 videl.vft = hw->vft;
1547                 videl.vbb = hw->vbb;
1548                 videl.vbe = hw->vbe;
1549                 videl.vdb = hw->vdb;
1550                 videl.vde = hw->vde;
1551                 videl.vss = hw->vss;
1552
1553                 videl.f_shift = 0; /* write enables Falcon palette, 0: 4 planes */
1554                 if (hw->ste_mode) {
1555                         videl.st_shift = hw->st_shift; /* write enables STE palette */
1556                 }
1557                 else {
1558                         /* IMPORTANT:
1559                          * set st_shift 0, so we can tell the screen-depth if f_shift==0.
1560                          * Writing 0 to f_shift enables 4 plane Falcon mode but
1561                          * doesn't set st_shift. st_shift!=0 (!=4planes) is impossible
1562                          * with Falcon palette.
1563                          */
1564                         videl.st_shift = 0;
1565                         /* now back to Falcon palette mode */
1566                         videl.f_shift = hw->f_shift;
1567                 }
1568                 /* writing to st_shift changed scn_width and vid_mode */
1569                 videl.xoffset = hw->xoffset;
1570                 shifter_f030.scn_width = hw->line_width;
1571                 shifter_f030.off_next = hw->line_offset;
1572                 videl.control = hw->vid_control;
1573                 videl.mode = hw->vid_mode;
1574         }
1575         if (f_pan_display) {
1576                 f_pan_display = 0;
1577                 videl.xoffset = current_par.hw.falcon.xoffset;
1578                 shifter_f030.off_next = current_par.hw.falcon.line_offset;
1579         }
1580         return IRQ_HANDLED;
1581 }
1582
1583
1584 static int falcon_pan_display( struct fb_var_screeninfo *var,
1585                                                            struct atafb_par *par )
1586 {
1587         int xoffset;
1588         int bpp = fb_display[fb_info.currcon].var.bits_per_pixel;
1589
1590         if (bpp == 1)
1591                 var->xoffset = up(var->xoffset, 32);
1592         if (bpp != 16)
1593                 par->hw.falcon.xoffset = var->xoffset & 15;
1594         else {
1595                 par->hw.falcon.xoffset = 0;
1596                 var->xoffset = up(var->xoffset, 2);
1597         }
1598         par->hw.falcon.line_offset = bpp *
1599                 (fb_display[fb_info.currcon].var.xres_virtual - fb_display[fb_info.currcon].var.xres) / 16;
1600         if (par->hw.falcon.xoffset)
1601                 par->hw.falcon.line_offset -= bpp;
1602         xoffset = var->xoffset - par->hw.falcon.xoffset;
1603
1604         par->screen_base = screen_base +
1605                 (var->yoffset * fb_display[fb_info.currcon].var.xres_virtual + xoffset) * bpp / 8;
1606         if (fbhw->set_screen_base)
1607                 fbhw->set_screen_base (par->screen_base);
1608         else
1609                 return -EINVAL; /* shouldn't happen */
1610         f_pan_display = 1;
1611         return 0;
1612 }
1613
1614
1615 static int falcon_getcolreg( unsigned regno, unsigned *red,
1616                                  unsigned *green, unsigned *blue,
1617                                  unsigned *transp, struct fb_info *info )
1618 {       unsigned long col;
1619
1620         if (regno > 255)
1621                 return 1;
1622         /* This works in STE-mode (with 4bit/color) since f030_col-registers
1623          * hold up to 6bit/color.
1624          * Even with hicolor r/g/b=5/6/5 bit!
1625          */
1626         col = f030_col[regno];
1627         *red = (col >> 16) & 0xff00;
1628         *green = (col >> 8) & 0xff00;
1629         *blue = (col << 8) & 0xff00;
1630         *transp = 0;
1631         return 0;
1632 }
1633
1634
1635 static int falcon_setcolreg( unsigned regno, unsigned red,
1636                                                          unsigned green, unsigned blue,
1637                                                          unsigned transp, struct fb_info *info )
1638 {
1639         if (regno > 255)
1640                 return 1;
1641         f030_col[regno] = (((red & 0xfc00) << 16) |
1642                            ((green & 0xfc00) << 8) |
1643                            ((blue & 0xfc00) >> 8));
1644         if (regno < 16) {
1645                 shifter_tt.color_reg[regno] =
1646                         (((red & 0xe000) >> 13) | ((red & 0x1000) >> 12) << 8) |
1647                         (((green & 0xe000) >> 13) | ((green & 0x1000) >> 12) << 4) |
1648                         ((blue & 0xe000) >> 13) | ((blue & 0x1000) >> 12);
1649 #ifdef FBCON_HAS_CFB16
1650                 fbcon_cfb16_cmap[regno] = ((red & 0xf800) |
1651                                            ((green & 0xfc00) >> 5) |
1652                                            ((blue & 0xf800) >> 11));
1653 #endif
1654         }
1655         return 0;
1656 }
1657
1658
1659 static int falcon_blank( int blank_mode )
1660 {
1661 /* ++guenther: we can switch off graphics by changing VDB and VDE,
1662  * so VIDEL doesn't hog the bus while saving.
1663  * (this may affect usleep()).
1664  */
1665         int vdb, vss, hbe, hss;
1666
1667         if (mon_type == F_MON_SM)       /* this doesn't work on SM124 */
1668                 return 1;
1669
1670         vdb = current_par.VDB;
1671         vss = current_par.VSS;
1672         hbe = current_par.HBE;
1673         hss = current_par.HSS;
1674
1675         if (blank_mode >= 1) {
1676                 /* disable graphics output (this speeds up the CPU) ... */
1677                 vdb = current_par.VFT + 1;
1678                 /* ... and blank all lines */
1679                 hbe = current_par.HHT + 2;
1680         }
1681         /* use VESA suspend modes on VGA monitors */
1682         if (mon_type == F_MON_VGA) {
1683                 if (blank_mode == 2 || blank_mode == 4)
1684                         vss = current_par.VFT + 1;
1685                 if (blank_mode == 3 || blank_mode == 4)
1686                         hss = current_par.HHT + 2;
1687         }
1688
1689         videl.vdb = vdb;
1690         videl.vss = vss;
1691         videl.hbe = hbe;
1692         videl.hss = hss;
1693
1694         return 0;
1695 }
1696
1697
1698 static int falcon_detect( void )
1699 {
1700         struct atafb_par par;
1701         unsigned char fhw;
1702
1703         /* Determine connected monitor and set monitor parameters */
1704         fhw = *(unsigned char*)0xffff8006;
1705         mon_type = fhw >> 6 & 0x3;
1706         /* bit 1 of fhw: 1=32 bit ram bus, 0=16 bit */
1707         f030_bus_width = fhw << 6 & 0x80;
1708         switch (mon_type) {
1709         case F_MON_SM:
1710                 fb_info.monspecs.vfmin = 70;
1711                 fb_info.monspecs.vfmax = 72;
1712                 fb_info.monspecs.hfmin = 35713;
1713                 fb_info.monspecs.hfmax = 35715;
1714                 break;
1715         case F_MON_SC:
1716         case F_MON_TV:
1717                 /* PAL...NTSC */
1718                 fb_info.monspecs.vfmin = 49; /* not 50, since TOS defaults to 49.9x Hz */
1719                 fb_info.monspecs.vfmax = 60;
1720                 fb_info.monspecs.hfmin = 15620;
1721                 fb_info.monspecs.hfmax = 15755;
1722                 break;
1723         }
1724         /* initialize hsync-len */
1725         f25.hsync = h_syncs[mon_type] / f25.t;
1726         f32.hsync = h_syncs[mon_type] / f32.t;
1727         if (fext.t)
1728                 fext.hsync = h_syncs[mon_type] / fext.t;
1729
1730         falcon_get_par(&par);
1731         falcon_encode_var(&atafb_predefined[0], &par);
1732
1733         /* Detected mode is always the "autodetect" slot */
1734         return 1;
1735 }
1736
1737 #endif /* ATAFB_FALCON */
1738
1739 /* ------------------- ST(E) specific functions ---------------------- */
1740
1741 #ifdef ATAFB_STE
1742
1743 static int stste_encode_fix( struct fb_fix_screeninfo *fix,
1744                                                          struct atafb_par *par )
1745
1746 {
1747         int mode;
1748
1749         strcpy(fix->id,"Atari Builtin");
1750         fix->smem_start = (unsigned long)real_screen_base;
1751         fix->smem_len = screen_len;
1752         fix->type = FB_TYPE_INTERLEAVED_PLANES;
1753         fix->type_aux = 2;
1754         fix->visual = FB_VISUAL_PSEUDOCOLOR;
1755         mode = par->hw.st.mode & 3;
1756         if (mode == ST_HIGH) {
1757                 fix->type = FB_TYPE_PACKED_PIXELS;
1758                 fix->type_aux = 0;
1759                 fix->visual = FB_VISUAL_MONO10;
1760         }
1761         if (ATARIHW_PRESENT(EXTD_SHIFTER)) {
1762                 fix->xpanstep = 16;
1763                 fix->ypanstep = 1;
1764         } else {
1765                 fix->xpanstep = 0;
1766                 fix->ypanstep = 0;
1767         }
1768         fix->ywrapstep = 0;
1769         fix->line_length = 0;
1770         fix->accel = FB_ACCEL_ATARIBLITT;
1771         return 0;
1772 }
1773
1774
1775 static int stste_decode_var( struct fb_var_screeninfo *var,
1776                                                   struct atafb_par *par )
1777 {
1778         int xres=var->xres;
1779         int yres=var->yres;
1780         int bpp=var->bits_per_pixel;
1781         int linelen;
1782         int yres_virtual = var->yres_virtual;
1783
1784         if (mono_moni) {
1785                 if (bpp > 1 || xres > sttt_xres || yres > st_yres)
1786                         return -EINVAL;
1787                 par->hw.st.mode=ST_HIGH;
1788                 xres=sttt_xres;
1789                 yres=st_yres;
1790                 bpp=1;
1791         } else {
1792                 if (bpp > 4 || xres > sttt_xres || yres > st_yres)
1793                         return -EINVAL;
1794                 if (bpp > 2) {
1795                         if (xres > sttt_xres/2 || yres > st_yres/2)
1796                                 return -EINVAL;
1797                         par->hw.st.mode=ST_LOW;
1798                         xres=sttt_xres/2;
1799                         yres=st_yres/2;
1800                         bpp=4;
1801                 }
1802                 else if (bpp > 1) {
1803                         if (xres > sttt_xres || yres > st_yres/2)
1804                                 return -EINVAL;
1805                         par->hw.st.mode=ST_MID;
1806                         xres=sttt_xres;
1807                         yres=st_yres/2;
1808                         bpp=2;
1809                 }
1810                 else
1811                         return -EINVAL;
1812         }
1813         if (yres_virtual <= 0)
1814                 yres_virtual = 0;
1815         else if (yres_virtual < yres)
1816                 yres_virtual = yres;
1817         if (var->sync & FB_SYNC_EXT)
1818                 par->hw.st.sync=(par->hw.st.sync & ~1) | 1;
1819         else
1820                 par->hw.st.sync=(par->hw.st.sync & ~1);
1821         linelen=xres*bpp/8;
1822         if (yres_virtual * linelen > screen_len && screen_len)
1823                 return -EINVAL;
1824         if (yres * linelen > screen_len && screen_len)
1825                 return -EINVAL;
1826         if (var->yoffset + yres > yres_virtual && yres_virtual)
1827                 return -EINVAL;
1828         par->yres_virtual = yres_virtual;
1829         par->screen_base=screen_base+ var->yoffset*linelen;
1830         return 0;
1831 }
1832
1833 static int stste_encode_var( struct fb_var_screeninfo *var,
1834                                                   struct atafb_par *par )
1835 {
1836         int linelen;
1837         memset(var, 0, sizeof(struct fb_var_screeninfo));
1838         var->red.offset=0;
1839         var->red.length = ATARIHW_PRESENT(EXTD_SHIFTER) ? 4 : 3;
1840         var->red.msb_right=0;
1841         var->grayscale=0;
1842
1843         var->pixclock=31041;
1844         var->left_margin=120;           /* these are incorrect */
1845         var->right_margin=100;
1846         var->upper_margin=8;
1847         var->lower_margin=16;
1848         var->hsync_len=140;
1849         var->vsync_len=30;
1850
1851         var->height=-1;
1852         var->width=-1;
1853
1854         if (!(par->hw.st.sync & 1))
1855                 var->sync=0;
1856         else
1857                 var->sync=FB_SYNC_EXT;
1858
1859         switch (par->hw.st.mode & 3) {
1860         case ST_LOW:
1861                 var->xres=sttt_xres/2;
1862                 var->yres=st_yres/2;
1863                 var->bits_per_pixel=4;
1864                 break;
1865         case ST_MID:
1866                 var->xres=sttt_xres;
1867                 var->yres=st_yres/2;
1868                 var->bits_per_pixel=2;
1869                 break;
1870         case ST_HIGH:
1871                 var->xres=sttt_xres;
1872                 var->yres=st_yres;
1873                 var->bits_per_pixel=1;
1874                 break;
1875         }
1876         var->blue=var->green=var->red;
1877         var->transp.offset=0;
1878         var->transp.length=0;
1879         var->transp.msb_right=0;
1880         var->xres_virtual=sttt_xres_virtual;
1881         linelen=var->xres_virtual * var->bits_per_pixel / 8;
1882         ovsc_addlen=linelen*(sttt_yres_virtual - st_yres);
1883
1884         if (! use_hwscroll)
1885                 var->yres_virtual=var->yres;
1886         else if (screen_len) {
1887                 if (par->yres_virtual)
1888                         var->yres_virtual = par->yres_virtual;
1889                 else
1890                         /* yres_virtual==0 means use maximum */
1891                         var->yres_virtual = screen_len / linelen;
1892         }
1893         else {
1894                 if (hwscroll < 0)
1895                         var->yres_virtual = 2 * var->yres;
1896                 else
1897                         var->yres_virtual=var->yres+hwscroll * 16;
1898         }
1899         var->xoffset=0;
1900         if (screen_base)
1901                 var->yoffset=(par->screen_base - screen_base)/linelen;
1902         else
1903                 var->yoffset=0;
1904         var->nonstd=0;
1905         var->activate=0;
1906         var->vmode=FB_VMODE_NONINTERLACED;
1907         return 0;
1908 }
1909
1910
1911 static void stste_get_par( struct atafb_par *par )
1912 {
1913         unsigned long addr;
1914         par->hw.st.mode=shifter_tt.st_shiftmode;
1915         par->hw.st.sync=shifter.syncmode;
1916         addr = ((shifter.bas_hi & 0xff) << 16) |
1917                ((shifter.bas_md & 0xff) << 8);
1918         if (ATARIHW_PRESENT(EXTD_SHIFTER))
1919                 addr |= (shifter.bas_lo & 0xff);
1920         par->screen_base = phys_to_virt(addr);
1921 }
1922
1923 static void stste_set_par( struct atafb_par *par )
1924 {
1925         shifter_tt.st_shiftmode=par->hw.st.mode;
1926         shifter.syncmode=par->hw.st.sync;
1927         /* only set screen_base if really necessary */
1928         if (current_par.screen_base != par->screen_base)
1929                 fbhw->set_screen_base(par->screen_base);
1930 }
1931
1932
1933 static int stste_getcolreg(unsigned regno, unsigned *red,
1934                            unsigned *green, unsigned *blue,
1935                            unsigned *transp, struct fb_info *info)
1936 {
1937         unsigned col, t;
1938
1939         if (regno > 15)
1940                 return 1;
1941         col = shifter_tt.color_reg[regno];
1942         if (ATARIHW_PRESENT(EXTD_SHIFTER)) {
1943                 t = ((col >> 7) & 0xe) | ((col >> 11) & 1);
1944                 t |= t << 4;
1945                 *red = t | (t << 8);
1946                 t = ((col >> 3) & 0xe) | ((col >> 7) & 1);
1947                 t |= t << 4;
1948                 *green = t | (t << 8);
1949                 t = ((col << 1) & 0xe) | ((col >> 3) & 1);
1950                 t |= t << 4;
1951                 *blue = t | (t << 8);
1952         }
1953         else {
1954                 t = (col >> 7) & 0xe;
1955                 t |= t << 4;
1956                 *red = t | (t << 8);
1957                 t = (col >> 3) & 0xe;
1958                 t |= t << 4;
1959                 *green = t | (t << 8);
1960                 t = (col << 1) & 0xe;
1961                 t |= t << 4;
1962                 *blue = t | (t << 8);
1963         }
1964         *transp = 0;
1965         return 0;
1966 }
1967
1968
1969 static int stste_setcolreg(unsigned regno, unsigned red,
1970                            unsigned green, unsigned blue,
1971                            unsigned transp, struct fb_info *info)
1972 {
1973         if (regno > 15)
1974                 return 1;
1975         red >>= 12;
1976         blue >>= 12;
1977         green >>= 12;
1978         if (ATARIHW_PRESENT(EXTD_SHIFTER))
1979                 shifter_tt.color_reg[regno] =
1980                         (((red & 0xe) >> 1) | ((red & 1) << 3) << 8) |
1981                         (((green & 0xe) >> 1) | ((green & 1) << 3) << 4) |
1982                         ((blue & 0xe) >> 1) | ((blue & 1) << 3);
1983         else
1984                 shifter_tt.color_reg[regno] =
1985                         ((red & 0xe) << 7) |
1986                         ((green & 0xe) << 3) |
1987                         ((blue & 0xe) >> 1);
1988         return 0;
1989 }
1990
1991
1992 static int stste_detect( void )
1993
1994 {       struct atafb_par par;
1995
1996         /* Determine the connected monitor: The DMA sound must be
1997          * disabled before reading the MFP GPIP, because the Sound
1998          * Done Signal and the Monochrome Detect are XORed together!
1999          */
2000         if (ATARIHW_PRESENT(PCM_8BIT)) {
2001                 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
2002                 udelay(20);     /* wait a while for things to settle down */
2003         }
2004         mono_moni = (mfp.par_dt_reg & 0x80) == 0;
2005
2006         stste_get_par(&par);
2007         stste_encode_var(&atafb_predefined[0], &par);
2008
2009         if (!ATARIHW_PRESENT(EXTD_SHIFTER))
2010                 use_hwscroll = 0;
2011         return 1;
2012 }
2013
2014 static void stste_set_screen_base(void *s_base)
2015 {
2016         unsigned long addr;
2017         addr= virt_to_phys(s_base);
2018         /* Setup Screen Memory */
2019         shifter.bas_hi=(unsigned char) ((addr & 0xff0000) >> 16);
2020         shifter.bas_md=(unsigned char) ((addr & 0x00ff00) >> 8);
2021         if (ATARIHW_PRESENT(EXTD_SHIFTER))
2022                 shifter.bas_lo=(unsigned char)  (addr & 0x0000ff);
2023 }
2024
2025 #endif /* ATAFB_STE */
2026
2027 /* Switching the screen size should be done during vsync, otherwise
2028  * the margins may get messed up. This is a well known problem of
2029  * the ST's video system.
2030  *
2031  * Unfortunately there is hardly any way to find the vsync, as the
2032  * vertical blank interrupt is no longer in time on machines with
2033  * overscan type modifications.
2034  *
2035  * We can, however, use Timer B to safely detect the black shoulder,
2036  * but then we've got to guess an appropriate delay to find the vsync.
2037  * This might not work on every machine.
2038  *
2039  * martin_rogge @ ki.maus.de, 8th Aug 1995
2040  */
2041
2042 #define LINE_DELAY  (mono_moni ? 30 : 70)
2043 #define SYNC_DELAY  (mono_moni ? 1500 : 2000)
2044
2045 /* SWITCH_ACIA may be used for Falcon (ScreenBlaster III internal!) */
2046 static void st_ovsc_switch(void)
2047 {
2048     unsigned long flags;
2049     register unsigned char old, new;
2050
2051     if (!(atari_switches & ATARI_SWITCH_OVSC_MASK))
2052         return;
2053     local_irq_save(flags);
2054
2055     mfp.tim_ct_b = 0x10;
2056     mfp.active_edge |= 8;
2057     mfp.tim_ct_b = 0;
2058     mfp.tim_dt_b = 0xf0;
2059     mfp.tim_ct_b = 8;
2060     while (mfp.tim_dt_b > 1)    /* TOS does it this way, don't ask why */
2061         ;
2062     new = mfp.tim_dt_b;
2063     do {
2064         udelay(LINE_DELAY);
2065         old = new;
2066         new = mfp.tim_dt_b;
2067     } while (old != new);
2068     mfp.tim_ct_b = 0x10;
2069     udelay(SYNC_DELAY);
2070
2071     if (atari_switches & ATARI_SWITCH_OVSC_IKBD)
2072         acia.key_ctrl = ACIA_DIV64 | ACIA_D8N1S | ACIA_RHTID | ACIA_RIE;
2073     if (atari_switches & ATARI_SWITCH_OVSC_MIDI)
2074         acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ACIA_RHTID;
2075     if (atari_switches & (ATARI_SWITCH_OVSC_SND6|ATARI_SWITCH_OVSC_SND7)) {
2076         sound_ym.rd_data_reg_sel = 14;
2077         sound_ym.wd_data = sound_ym.rd_data_reg_sel |
2078                            ((atari_switches&ATARI_SWITCH_OVSC_SND6) ? 0x40:0) |
2079                            ((atari_switches&ATARI_SWITCH_OVSC_SND7) ? 0x80:0);
2080     }
2081     local_irq_restore(flags);
2082 }
2083
2084 /* ------------------- External Video ---------------------- */
2085
2086 #ifdef ATAFB_EXT
2087
2088 static int ext_encode_fix( struct fb_fix_screeninfo *fix,
2089                                                    struct atafb_par *par )
2090
2091 {
2092         strcpy(fix->id,"Unknown Extern");
2093         fix->smem_start = (unsigned long)external_addr;
2094         fix->smem_len = PAGE_ALIGN(external_len);
2095         if (external_depth == 1) {
2096                 fix->type = FB_TYPE_PACKED_PIXELS;
2097                 /* The letters 'n' and 'i' in the "atavideo=external:" stand
2098                  * for "normal" and "inverted", rsp., in the monochrome case */
2099                 fix->visual =
2100                         (external_pmode == FB_TYPE_INTERLEAVED_PLANES ||
2101                          external_pmode == FB_TYPE_PACKED_PIXELS) ?
2102                                 FB_VISUAL_MONO10 :
2103                                         FB_VISUAL_MONO01;
2104         }
2105         else {
2106                 /* Use STATIC if we don't know how to access color registers */
2107                 int visual = external_vgaiobase ?
2108                                          FB_VISUAL_PSEUDOCOLOR :
2109                                          FB_VISUAL_STATIC_PSEUDOCOLOR;
2110                 switch (external_pmode) {
2111                     case -1:              /* truecolor */
2112                         fix->type=FB_TYPE_PACKED_PIXELS;
2113                         fix->visual=FB_VISUAL_TRUECOLOR;
2114                         break;
2115                     case FB_TYPE_PACKED_PIXELS:
2116                         fix->type=FB_TYPE_PACKED_PIXELS;
2117                         fix->visual=visual;
2118                         break;
2119                     case FB_TYPE_PLANES:
2120                         fix->type=FB_TYPE_PLANES;
2121                         fix->visual=visual;
2122                         break;
2123                     case FB_TYPE_INTERLEAVED_PLANES:
2124                         fix->type=FB_TYPE_INTERLEAVED_PLANES;
2125                         fix->type_aux=2;
2126                         fix->visual=visual;
2127                         break;
2128                 }
2129         }
2130         fix->xpanstep = 0;
2131         fix->ypanstep = 0;
2132         fix->ywrapstep = 0;
2133         fix->line_length = 0;
2134         return 0;
2135 }
2136
2137
2138 static int ext_decode_var( struct fb_var_screeninfo *var,
2139                                                    struct atafb_par *par )
2140 {
2141         struct fb_var_screeninfo *myvar = &atafb_predefined[0];
2142
2143         if (var->bits_per_pixel > myvar->bits_per_pixel ||
2144                 var->xres > myvar->xres ||
2145                 var->xres_virtual > myvar->xres_virtual ||
2146                 var->yres > myvar->yres ||
2147                 var->xoffset > 0 ||
2148                 var->yoffset > 0)
2149                 return -EINVAL;
2150         return 0;
2151 }
2152
2153
2154 static int ext_encode_var( struct fb_var_screeninfo *var,
2155                                                    struct atafb_par *par )
2156 {
2157         memset(var, 0, sizeof(struct fb_var_screeninfo));
2158         var->red.offset=0;
2159         var->red.length=(external_pmode == -1) ? external_depth/3 :
2160                         (external_vgaiobase ? external_bitspercol : 0);
2161         var->red.msb_right=0;
2162         var->grayscale=0;
2163
2164         var->pixclock=31041;
2165         var->left_margin=120;           /* these are surely incorrect   */
2166         var->right_margin=100;
2167         var->upper_margin=8;
2168         var->lower_margin=16;
2169         var->hsync_len=140;
2170         var->vsync_len=30;
2171
2172         var->height=-1;
2173         var->width=-1;
2174
2175         var->sync=0;
2176
2177         var->xres = external_xres;
2178         var->yres = external_yres;
2179         var->xres_virtual = external_xres_virtual;
2180         var->bits_per_pixel = external_depth;
2181
2182         var->blue=var->green=var->red;
2183         var->transp.offset=0;
2184         var->transp.length=0;
2185         var->transp.msb_right=0;
2186         var->yres_virtual=var->yres;
2187         var->xoffset=0;
2188         var->yoffset=0;
2189         var->nonstd=0;
2190         var->activate=0;
2191         var->vmode=FB_VMODE_NONINTERLACED;
2192         return 0;
2193 }
2194
2195
2196 static void ext_get_par( struct atafb_par *par )
2197 {
2198         par->screen_base = external_addr;
2199 }
2200
2201 static void ext_set_par( struct atafb_par *par )
2202 {
2203 }
2204
2205 #define OUTB(port,val) \
2206         *((unsigned volatile char *) ((port)+external_vgaiobase))=(val)
2207 #define INB(port) \
2208         (*((unsigned volatile char *) ((port)+external_vgaiobase)))
2209 #define DACDelay                                \
2210         do {                                    \
2211                 unsigned char tmp=INB(0x3da);   \
2212                 tmp=INB(0x3da);                 \
2213         } while (0)
2214
2215 static int ext_getcolreg( unsigned regno, unsigned *red,
2216                                                   unsigned *green, unsigned *blue,
2217                                                   unsigned *transp, struct fb_info *info )
2218 {
2219         if (! external_vgaiobase)
2220                 return 1;
2221
2222             *red   = ext_color[regno].red;
2223             *green = ext_color[regno].green;
2224             *blue  = ext_color[regno].blue;
2225             *transp=0;
2226             return 0;
2227 }
2228
2229 static int ext_setcolreg( unsigned regno, unsigned red,
2230                                                   unsigned green, unsigned blue,
2231                                                   unsigned transp, struct fb_info *info )
2232
2233 {       unsigned char colmask = (1 << external_bitspercol) - 1;
2234
2235         if (! external_vgaiobase)
2236                 return 1;
2237
2238         ext_color[regno].red = red;
2239         ext_color[regno].green = green;
2240         ext_color[regno].blue = blue;
2241
2242         switch (external_card_type) {
2243           case IS_VGA:
2244             OUTB(0x3c8, regno);
2245             DACDelay;
2246             OUTB(0x3c9, red & colmask);
2247             DACDelay;
2248             OUTB(0x3c9, green & colmask);
2249             DACDelay;
2250             OUTB(0x3c9, blue & colmask);
2251             DACDelay;
2252             return 0;
2253
2254           case IS_MV300:
2255             OUTB((MV300_reg[regno] << 2)+1, red);
2256             OUTB((MV300_reg[regno] << 2)+1, green);
2257             OUTB((MV300_reg[regno] << 2)+1, blue);
2258             return 0;
2259
2260           default:
2261             return 1;
2262           }
2263 }
2264
2265
2266 static int ext_detect( void )
2267
2268 {
2269         struct fb_var_screeninfo *myvar = &atafb_predefined[0];
2270         struct atafb_par dummy_par;
2271
2272         myvar->xres = external_xres;
2273         myvar->xres_virtual = external_xres_virtual;
2274         myvar->yres = external_yres;
2275         myvar->bits_per_pixel = external_depth;
2276         ext_encode_var(myvar, &dummy_par);
2277         return 1;
2278 }
2279
2280 #endif /* ATAFB_EXT */
2281
2282 /* ------ This is the same for most hardware types -------- */
2283
2284 static void set_screen_base(void *s_base)
2285 {
2286         unsigned long addr;
2287         addr= virt_to_phys(s_base);
2288         /* Setup Screen Memory */
2289         shifter.bas_hi=(unsigned char) ((addr & 0xff0000) >> 16);
2290         shifter.bas_md=(unsigned char) ((addr & 0x00ff00) >> 8);
2291         shifter.bas_lo=(unsigned char)  (addr & 0x0000ff);
2292 }
2293
2294
2295 static int pan_display( struct fb_var_screeninfo *var,
2296                         struct atafb_par *par )
2297 {
2298         if (!fbhw->set_screen_base ||
2299                 (!ATARIHW_PRESENT(EXTD_SHIFTER) && var->xoffset))
2300                 return -EINVAL;
2301         var->xoffset = up(var->xoffset, 16);
2302         par->screen_base = screen_base +
2303                 (var->yoffset * fb_display[fb_info.currcon].var.xres_virtual + var->xoffset)
2304                 * fb_display[fb_info.currcon].var.bits_per_pixel / 8;
2305         fbhw->set_screen_base (par->screen_base);
2306         return 0;
2307 }
2308
2309
2310 /* ------------ Interfaces to hardware functions ------------ */
2311
2312
2313 #ifdef ATAFB_TT
2314 static struct fb_hwswitch tt_switch = {
2315         tt_detect, tt_encode_fix, tt_decode_var, tt_encode_var,
2316         tt_get_par, tt_set_par, tt_getcolreg,
2317         set_screen_base, NULL, pan_display
2318 };
2319 #endif
2320
2321 #ifdef ATAFB_FALCON
2322 static struct fb_hwswitch falcon_switch = {
2323         falcon_detect, falcon_encode_fix, falcon_decode_var, falcon_encode_var,
2324         falcon_get_par, falcon_set_par, falcon_getcolreg,
2325         set_screen_base, falcon_blank, falcon_pan_display
2326 };
2327 #endif
2328
2329 #ifdef ATAFB_STE
2330 static struct fb_hwswitch st_switch = {
2331         stste_detect, stste_encode_fix, stste_decode_var, stste_encode_var,
2332         stste_get_par, stste_set_par, stste_getcolreg,
2333         stste_set_screen_base, NULL, pan_display
2334 };
2335 #endif
2336
2337 #ifdef ATAFB_EXT
2338 static struct fb_hwswitch ext_switch = {
2339         ext_detect, ext_encode_fix, ext_decode_var, ext_encode_var,
2340         ext_get_par, ext_set_par, ext_getcolreg, NULL, NULL, NULL
2341 };
2342 #endif
2343
2344
2345
2346 static void atafb_get_par( struct atafb_par *par )
2347 {
2348         if (current_par_valid) {
2349                 *par=current_par;
2350         }
2351         else
2352                 fbhw->get_par(par);
2353 }
2354
2355
2356 static void atafb_set_par( struct atafb_par *par )
2357 {
2358         fbhw->set_par(par);
2359         current_par=*par;
2360         current_par_valid=1;
2361 }
2362
2363
2364
2365 /* =========================================================== */
2366 /* ============== Hardware Independent Functions ============= */
2367 /* =========================================================== */
2368
2369
2370 /* used for hardware scrolling */
2371
2372 static int
2373 fb_update_var(int con, struct fb_info *info)
2374 {
2375         int off=fb_display[con].var.yoffset*fb_display[con].var.xres_virtual*
2376                         fb_display[con].var.bits_per_pixel>>3;
2377
2378         current_par.screen_base=screen_base + off;
2379
2380         if (fbhw->set_screen_base)
2381                 fbhw->set_screen_base(current_par.screen_base);
2382         return 0;
2383 }
2384
2385 static int
2386 do_fb_set_var(struct fb_var_screeninfo *var, int isactive)
2387 {
2388         int err,activate;
2389         struct atafb_par par;
2390         if ((err=fbhw->decode_var(var, &par)))
2391                 return err;
2392         activate=var->activate;
2393         if (((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) && isactive)
2394                 atafb_set_par(&par);
2395         fbhw->encode_var(var, &par);
2396         var->activate=activate;
2397         return 0;
2398 }
2399
2400 static int
2401 atafb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
2402 {
2403         struct atafb_par par;
2404         if (con == -1)
2405                 atafb_get_par(&par);
2406         else {
2407           int err;
2408                 if ((err=fbhw->decode_var(&fb_display[con].var,&par)))
2409                   return err;
2410         }
2411         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
2412         return fbhw->encode_fix(fix, &par);
2413 }
2414
2415 static int
2416 atafb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
2417 {
2418         struct atafb_par par;
2419         if (con == -1) {
2420                 atafb_get_par(&par);
2421                 fbhw->encode_var(var, &par);
2422         }
2423         else
2424                 *var=fb_display[con].var;
2425         return 0;
2426 }
2427
2428 static void
2429 atafb_set_disp(int con, struct fb_info *info)
2430 {
2431         struct fb_fix_screeninfo fix;
2432         struct fb_var_screeninfo var;
2433         struct display *display;
2434
2435         if (con >= 0)
2436                 display = &fb_display[con];
2437         else
2438                 display = &disp;        /* used during initialization */
2439
2440         atafb_get_fix(&fix, con, info);
2441         atafb_get_var(&var, con, info);
2442         if (con == -1)
2443                 con=0;
2444         info->screen_base = (void *)fix.smem_start;
2445         display->visual = fix.visual;
2446         display->type = fix.type;
2447         display->type_aux = fix.type_aux;
2448         display->ypanstep = fix.ypanstep;
2449         display->ywrapstep = fix.ywrapstep;
2450         display->line_length = fix.line_length;
2451         if (fix.visual != FB_VISUAL_PSEUDOCOLOR &&
2452                 fix.visual != FB_VISUAL_DIRECTCOLOR)
2453                 display->can_soft_blank = 0;
2454         else
2455                 display->can_soft_blank = 1;
2456         display->inverse =
2457             (fix.visual == FB_VISUAL_MONO01 ? !inverse : inverse);
2458         switch (fix.type) {
2459             case FB_TYPE_INTERLEAVED_PLANES:
2460                 switch (var.bits_per_pixel) {
2461 #ifdef FBCON_HAS_IPLAN2P2
2462                     case 2:
2463                         display->dispsw = &fbcon_iplan2p2;
2464                         break;
2465 #endif
2466 #ifdef FBCON_HAS_IPLAN2P4
2467                     case 4:
2468                         display->dispsw = &fbcon_iplan2p4;
2469                         break;
2470 #endif
2471 #ifdef FBCON_HAS_IPLAN2P8
2472                     case 8:
2473                         display->dispsw = &fbcon_iplan2p8;
2474                         break;
2475 #endif
2476                 }
2477                 break;
2478             case FB_TYPE_PACKED_PIXELS:
2479                 switch (var.bits_per_pixel) {
2480 #ifdef FBCON_HAS_MFB
2481                     case 1:
2482                         display->dispsw = &fbcon_mfb;
2483                         break;
2484 #endif
2485 #ifdef FBCON_HAS_CFB8
2486                     case 8:
2487                         display->dispsw = &fbcon_cfb8;
2488                         break;
2489 #endif
2490 #ifdef FBCON_HAS_CFB16
2491                     case 16:
2492                         display->dispsw = &fbcon_cfb16;
2493                         display->dispsw_data = fbcon_cfb16_cmap;
2494                         break;
2495 #endif
2496                 }
2497                 break;
2498         }
2499 }
2500
2501 static int
2502 atafb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
2503 {
2504         int err,oldxres,oldyres,oldbpp,oldxres_virtual,
2505             oldyres_virtual,oldyoffset;
2506         if ((err=do_fb_set_var(var, con==info->currcon)))
2507                 return err;
2508         if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
2509                 oldxres=fb_display[con].var.xres;
2510                 oldyres=fb_display[con].var.yres;
2511                 oldxres_virtual=fb_display[con].var.xres_virtual;
2512                 oldyres_virtual=fb_display[con].var.yres_virtual;
2513                 oldbpp=fb_display[con].var.bits_per_pixel;
2514                 oldyoffset=fb_display[con].var.yoffset;
2515                 fb_display[con].var=*var;
2516                 if (oldxres != var->xres || oldyres != var->yres
2517                     || oldxres_virtual != var->xres_virtual
2518                     || oldyres_virtual != var->yres_virtual
2519                     || oldbpp != var->bits_per_pixel
2520                     || oldyoffset != var->yoffset) {
2521                         atafb_set_disp(con, info);
2522                         (*fb_info.changevar)(con);
2523                         fb_alloc_cmap(&fb_display[con].cmap, 0, 0);
2524                         do_install_cmap(con, info);
2525                 }
2526         }
2527         var->activate=0;
2528         return 0;
2529 }
2530
2531
2532
2533 static int
2534 atafb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
2535 {
2536         if (con == info->currcon) /* current console ? */
2537                 return fb_get_cmap(cmap, kspc, fbhw->getcolreg, info);
2538         else
2539                 if (fb_display[con].cmap.len) /* non default colormap ? */
2540                         fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
2541                 else
2542                         fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
2543                                      cmap, kspc ? 0 : 2);
2544         return 0;
2545 }
2546
2547 static int
2548 atafb_pan_display(struct fb_var_screeninfo *var, int con, struct fb_info *info)
2549 {
2550         int xoffset = var->xoffset;
2551         int yoffset = var->yoffset;
2552         int err;
2553
2554         if (   xoffset < 0 || xoffset + fb_display[con].var.xres > fb_display[con].var.xres_virtual
2555             || yoffset < 0 || yoffset + fb_display[con].var.yres > fb_display[con].var.yres_virtual)
2556                 return -EINVAL;
2557
2558         if (con == info->currcon) {
2559                 if (fbhw->pan_display) {
2560                         if ((err = fbhw->pan_display(var, &current_par)))
2561                                 return err;
2562                 }
2563                 else
2564                         return -EINVAL;
2565         }
2566         fb_display[con].var.xoffset = var->xoffset;
2567         fb_display[con].var.yoffset = var->yoffset;
2568         return 0;
2569 }
2570
2571 static int
2572 atafb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
2573 {
2574         switch (cmd) {
2575 #ifdef FBCMD_GET_CURRENTPAR
2576         case FBCMD_GET_CURRENTPAR:
2577                 if (copy_to_user((void *)arg, (void *)&current_par,
2578                                  sizeof(struct atafb_par)))
2579                         return -EFAULT;
2580                 return 0;
2581 #endif
2582 #ifdef FBCMD_SET_CURRENTPAR
2583         case FBCMD_SET_CURRENTPAR:
2584                 if (copy_from_user((void *)&current_par, (void *)arg,
2585                                    sizeof(struct atafb_par)))
2586                         return -EFAULT;
2587                 atafb_set_par(&current_par);
2588                 return 0;
2589 #endif
2590         }
2591         return -EINVAL;
2592 }
2593
2594 /* (un)blank/poweroff
2595  * 0 = unblank
2596  * 1 = blank
2597  * 2 = suspend vsync
2598  * 3 = suspend hsync
2599  * 4 = off
2600  */
2601 static int
2602 atafb_blank(int blank, struct fb_info *info)
2603 {
2604         unsigned short black[16];
2605         struct fb_cmap cmap;
2606         if (fbhw->blank && !fbhw->blank(blank))
2607                 return 1;
2608         if (blank) {
2609                 memset(black, 0, 16*sizeof(unsigned short));
2610                 cmap.red=black;
2611                 cmap.green=black;
2612                 cmap.blue=black;
2613                 cmap.transp=NULL;
2614                 cmap.start=0;
2615                 cmap.len=16;
2616                 fb_set_cmap(&cmap, 1, info);
2617         }
2618         else
2619                 do_install_cmap(info->currcon, info);
2620         return 0;
2621 }
2622
2623 static struct fb_ops atafb_ops = {
2624         .owner =        THIS_MODULE,
2625         .fb_get_fix =   atafb_get_fix,
2626         .fb_get_var =   atafb_get_var,
2627         .fb_set_var =   atafb_set_var,
2628         .fb_get_cmap =  atafb_get_cmap,
2629         .fb_set_cmap =  gen_set_cmap,
2630         .fb_pan_display =atafb_pan_display,
2631         .fb_blank =     atafb_blank,
2632         .fb_ioctl =     atafb_ioctl,
2633 };
2634
2635 static void
2636 check_default_par( int detected_mode )
2637 {
2638         char default_name[10];
2639         int i;
2640         struct fb_var_screeninfo var;
2641         unsigned long min_mem;
2642
2643         /* First try the user supplied mode */
2644         if (default_par) {
2645                 var=atafb_predefined[default_par-1];
2646                 var.activate = FB_ACTIVATE_TEST;
2647                 if (do_fb_set_var(&var,1))
2648                         default_par=0;          /* failed */
2649         }
2650         /* Next is the autodetected one */
2651         if (! default_par) {
2652                 var=atafb_predefined[detected_mode-1]; /* autodetect */
2653                 var.activate = FB_ACTIVATE_TEST;
2654                 if (!do_fb_set_var(&var,1))
2655                         default_par=detected_mode;
2656         }
2657         /* If that also failed, try some default modes... */
2658         if (! default_par) {
2659                 /* try default1, default2... */
2660                 for (i=1 ; i < 10 ; i++) {
2661                         sprintf(default_name,"default%d",i);
2662                         default_par=get_video_mode(default_name);
2663                         if (! default_par)
2664                                 panic("can't set default video mode");
2665                         var=atafb_predefined[default_par-1];
2666                         var.activate = FB_ACTIVATE_TEST;
2667                         if (! do_fb_set_var(&var,1))
2668                                 break;  /* ok */
2669                 }
2670         }
2671         min_mem=var.xres_virtual * var.yres_virtual * var.bits_per_pixel/8;
2672         if (default_mem_req < min_mem)
2673                 default_mem_req=min_mem;
2674 }
2675
2676 static int
2677 atafb_switch(int con, struct fb_info *info)
2678 {
2679         /* Do we have to save the colormap ? */
2680         if (fb_display[info->currcon].cmap.len)
2681                 fb_get_cmap(&fb_display[info->currcon].cmap, 1, fbhw->getcolreg,
2682                             info);
2683         do_fb_set_var(&fb_display[con].var,1);
2684         info->currcon=con;
2685         /* Install new colormap */
2686         do_install_cmap(con, info);
2687         return 0;
2688 }
2689
2690 int __init atafb_init(void)
2691 {
2692         int pad;
2693         int detected_mode;
2694         unsigned long mem_req;
2695
2696         if (!MACH_IS_ATARI)
2697                 return -ENXIO;
2698
2699         do {
2700 #ifdef ATAFB_EXT
2701                 if (external_addr) {
2702                         fbhw = &ext_switch;
2703                         atafb_ops.fb_setcolreg = &ext_setcolreg;
2704                         break;
2705                 }
2706 #endif
2707 #ifdef ATAFB_TT
2708                 if (ATARIHW_PRESENT(TT_SHIFTER)) {
2709                         fbhw = &tt_switch;
2710                         atafb_ops.fb_setcolreg = &tt_setcolreg;
2711                         break;
2712                 }
2713 #endif
2714 #ifdef ATAFB_FALCON
2715                 if (ATARIHW_PRESENT(VIDEL_SHIFTER)) {
2716                         fbhw = &falcon_switch;
2717                         atafb_ops.fb_setcolreg = &falcon_setcolreg;
2718                         request_irq(IRQ_AUTO_4, falcon_vbl_switcher, IRQ_TYPE_PRIO,
2719                                     "framebuffer/modeswitch", falcon_vbl_switcher);
2720                         break;
2721                 }
2722 #endif
2723 #ifdef ATAFB_STE
2724                 if (ATARIHW_PRESENT(STND_SHIFTER) ||
2725                     ATARIHW_PRESENT(EXTD_SHIFTER)) {
2726                         fbhw = &st_switch;
2727                         atafb_ops.fb_setcolreg = &stste_setcolreg;
2728                         break;
2729                 }
2730                 fbhw = &st_switch;
2731                 atafb_ops.fb_setcolreg = &stste_setcolreg;
2732                 printk("Cannot determine video hardware; defaulting to ST(e)\n");
2733 #else /* ATAFB_STE */
2734                 /* no default driver included */
2735                 /* Nobody will ever see this message :-) */
2736                 panic("Cannot initialize video hardware");
2737 #endif
2738         } while (0);
2739
2740         /* Multisync monitor capabilities */
2741         /* Atari-TOS defaults if no boot option present */
2742         if (fb_info.monspecs.hfmin == 0) {
2743             fb_info.monspecs.hfmin = 31000;
2744             fb_info.monspecs.hfmax = 32000;
2745             fb_info.monspecs.vfmin = 58;
2746             fb_info.monspecs.vfmax = 62;
2747         }
2748
2749         detected_mode = fbhw->detect();
2750         check_default_par(detected_mode);
2751 #ifdef ATAFB_EXT
2752         if (!external_addr) {
2753 #endif /* ATAFB_EXT */
2754                 mem_req = default_mem_req + ovsc_offset + ovsc_addlen;
2755                 mem_req = PAGE_ALIGN(mem_req) + PAGE_SIZE;
2756                 screen_base = atari_stram_alloc(mem_req, "atafb");
2757                 if (!screen_base)
2758                         panic("Cannot allocate screen memory");
2759                 memset(screen_base, 0, mem_req);
2760                 pad = -(unsigned long)screen_base & (PAGE_SIZE-1);
2761                 screen_base+=pad;
2762                 real_screen_base=screen_base+ovsc_offset;
2763                 screen_len = (mem_req - pad - ovsc_offset) & PAGE_MASK;
2764                 st_ovsc_switch();
2765                 if (CPU_IS_040_OR_060) {
2766                         /* On a '040+, the cache mode of video RAM must be set to
2767                          * write-through also for internal video hardware! */
2768                         cache_push(virt_to_phys(screen_base), screen_len);
2769                         kernel_set_cachemode(screen_base, screen_len,
2770                                              IOMAP_WRITETHROUGH);
2771                 }
2772 #ifdef ATAFB_EXT
2773         }
2774         else {
2775                 /* Map the video memory (physical address given) to somewhere
2776                  * in the kernel address space.
2777                  */
2778                 external_addr =
2779                   ioremap_writethrough((unsigned long)external_addr,
2780                                        external_len);
2781                 if (external_vgaiobase)
2782                         external_vgaiobase =
2783                           (unsigned long)ioremap(external_vgaiobase, 0x10000);
2784                 screen_base      =
2785                 real_screen_base = external_addr;
2786                 screen_len       = external_len & PAGE_MASK;
2787                 memset (screen_base, 0, external_len);
2788         }
2789 #endif /* ATAFB_EXT */
2790
2791         strcpy(fb_info.modename, "Atari Builtin ");
2792         fb_info.changevar = NULL;
2793         fb_info.fbops = &atafb_ops;
2794         fb_info.disp = &disp;
2795         fb_info.currcon = -1;
2796         fb_info.switch_con = &atafb_switch;
2797         fb_info.updatevar = &fb_update_var;
2798         fb_info.flags = FBINFO_FLAG_DEFAULT;
2799         do_fb_set_var(&atafb_predefined[default_par-1], 1);
2800         strcat(fb_info.modename, fb_var_names[default_par-1][0]);
2801
2802         atafb_get_var(&disp.var, -1, &fb_info);
2803         atafb_set_disp(-1, &fb_info);
2804         do_install_cmap(0, &fb_info);
2805
2806         if (register_framebuffer(&fb_info) < 0) {
2807 #ifdef ATAFB_EXT
2808                 if (external_addr) {
2809                         iounmap(external_addr);
2810                         external_addr = NULL;
2811                 }
2812                 if (external_vgaiobase) {
2813                         iounmap((void*)external_vgaiobase);
2814                         external_vgaiobase = 0;
2815                 }
2816 #endif
2817                 return -EINVAL;
2818         }
2819
2820         printk("Determined %dx%d, depth %d\n",
2821                disp.var.xres, disp.var.yres, disp.var.bits_per_pixel);
2822         if ((disp.var.xres != disp.var.xres_virtual) ||
2823             (disp.var.yres != disp.var.yres_virtual))
2824            printk("   virtual %dx%d\n",
2825                           disp.var.xres_virtual, disp.var.yres_virtual);
2826         printk("fb%d: %s frame buffer device, using %dK of video memory\n",
2827                fb_info.node, fb_info.modename, screen_len>>10);
2828
2829         /* TODO: This driver cannot be unloaded yet */
2830         return 0;
2831 }
2832
2833
2834 #ifdef ATAFB_EXT
2835 static void __init atafb_setup_ext(char *spec)
2836 {
2837         int             xres, xres_virtual, yres, depth, planes;
2838         unsigned long addr, len;
2839         char *p;
2840
2841         /* Format is: <xres>;<yres>;<depth>;<plane organ.>;
2842          *            <screen mem addr>
2843          *            [;<screen mem length>[;<vgaiobase>[;<bits-per-col>[;<colorreg-type>
2844          *            [;<xres-virtual>]]]]]
2845          *
2846          * 09/23/97     Juergen
2847          * <xres_virtual>:      hardware's x-resolution (f.e. ProMST)
2848          *
2849          * Even xres_virtual is available, we neither support panning nor hw-scrolling!
2850          */
2851         if (!(p = strsep(&spec, ";")) || !*p)
2852             return;
2853         xres_virtual = xres = simple_strtoul(p, NULL, 10);
2854         if (xres <= 0)
2855             return;
2856
2857         if (!(p = strsep(&spec, ";")) || !*p)
2858             return;
2859         yres = simple_strtoul(p, NULL, 10);
2860         if (yres <= 0)
2861             return;
2862
2863         if (!(p = strsep(&spec, ";")) || !*p)
2864             return;
2865         depth = simple_strtoul(p, NULL, 10);
2866         if (depth != 1 && depth != 2 && depth != 4 && depth != 8 &&
2867                 depth != 16 && depth != 24)
2868             return;
2869
2870         if (!(p = strsep(&spec, ";")) || !*p)
2871             return;
2872         if (*p == 'i')
2873                 planes = FB_TYPE_INTERLEAVED_PLANES;
2874         else if (*p == 'p')
2875                 planes = FB_TYPE_PACKED_PIXELS;
2876         else if (*p == 'n')
2877                 planes = FB_TYPE_PLANES;
2878         else if (*p == 't')
2879                 planes = -1; /* true color */
2880         else
2881                 return;
2882
2883
2884         if (!(p = strsep(&spec, ";")) || !*p)
2885                 return;
2886         addr = simple_strtoul(p, NULL, 0);
2887
2888         if (!(p = strsep(&spec, ";")) || !*p)
2889                 len = xres*yres*depth/8;
2890         else
2891                 len = simple_strtoul(p, NULL, 0);
2892
2893         if ((p = strsep(&spec, ";")) && *p) {
2894                 external_vgaiobase=simple_strtoul(p, NULL, 0);
2895         }
2896
2897         if ((p = strsep(&spec, ";")) && *p) {
2898                 external_bitspercol = simple_strtoul(p, NULL, 0);
2899                 if (external_bitspercol > 8)
2900                         external_bitspercol = 8;
2901                 else if (external_bitspercol < 1)
2902                         external_bitspercol = 1;
2903         }
2904
2905         if ((p = strsep(&spec, ";")) && *p) {
2906                 if (!strcmp(p, "vga"))
2907                         external_card_type = IS_VGA;
2908                 if (!strcmp(p, "mv300"))
2909                         external_card_type = IS_MV300;
2910         }
2911
2912         if ((p = strsep(&spec, ";")) && *p) {
2913                 xres_virtual = simple_strtoul(p, NULL, 10);
2914                 if (xres_virtual < xres)
2915                         xres_virtual = xres;
2916                 if (xres_virtual*yres*depth/8 > len)
2917                         len=xres_virtual*yres*depth/8;
2918         }
2919
2920         external_xres  = xres;
2921         external_xres_virtual  = xres_virtual;
2922         external_yres  = yres;
2923         external_depth = depth;
2924         external_pmode = planes;
2925         external_addr  = (void *)addr;
2926         external_len   = len;
2927
2928         if (external_card_type == IS_MV300)
2929           switch (external_depth) {
2930             case 1:
2931               MV300_reg = MV300_reg_1bit;
2932               break;
2933             case 4:
2934               MV300_reg = MV300_reg_4bit;
2935               break;
2936             case 8:
2937               MV300_reg = MV300_reg_8bit;
2938               break;
2939             }
2940 }
2941 #endif /* ATAFB_EXT */
2942
2943
2944 static void __init atafb_setup_int(char *spec)
2945 {
2946         /* Format to config extended internal video hardware like OverScan:
2947         "internal:<xres>;<yres>;<xres_max>;<yres_max>;<offset>"
2948         Explanation:
2949         <xres>: x-resolution
2950         <yres>: y-resolution
2951         The following are only needed if you have an overscan which
2952         needs a black border:
2953         <xres_max>: max. length of a line in pixels your OverScan hardware would allow
2954         <yres_max>: max. number of lines your OverScan hardware would allow
2955         <offset>: Offset from physical beginning to visible beginning
2956                   of screen in bytes
2957         */
2958         int xres;
2959         char *p;
2960
2961         if (!(p = strsep(&spec, ";")) || !*p)
2962                 return;
2963         xres = simple_strtoul(p, NULL, 10);
2964         if (!(p = strsep(&spec, ";")) || !*p)
2965                 return;
2966         sttt_xres=xres;
2967         tt_yres=st_yres=simple_strtoul(p, NULL, 10);
2968         if ((p=strsep(&spec, ";")) && *p) {
2969                 sttt_xres_virtual=simple_strtoul(p, NULL, 10);
2970         }
2971         if ((p=strsep(&spec, ";")) && *p) {
2972                 sttt_yres_virtual=simple_strtoul(p, NULL, 0);
2973         }
2974         if ((p=strsep(&spec, ";")) && *p) {
2975                 ovsc_offset=simple_strtoul(p, NULL, 0);
2976         }
2977
2978         if (ovsc_offset || (sttt_yres_virtual != st_yres))
2979                 use_hwscroll=0;
2980 }
2981
2982
2983 #ifdef ATAFB_FALCON
2984 static void __init atafb_setup_mcap(char *spec)
2985 {
2986         char *p;
2987         int vmin, vmax, hmin, hmax;
2988
2989         /* Format for monitor capabilities is: <Vmin>;<Vmax>;<Hmin>;<Hmax>
2990          * <V*> vertical freq. in Hz
2991          * <H*> horizontal freq. in kHz
2992          */
2993         if (!(p = strsep(&spec, ";")) || !*p)
2994                 return;
2995         vmin = simple_strtoul(p, NULL, 10);
2996         if (vmin <= 0)
2997                 return;
2998         if (!(p = strsep(&spec, ";")) || !*p)
2999                 return;
3000         vmax = simple_strtoul(p, NULL, 10);
3001         if (vmax <= 0 || vmax <= vmin)
3002                 return;
3003         if (!(p = strsep(&spec, ";")) || !*p)
3004                 return;
3005         hmin = 1000 * simple_strtoul(p, NULL, 10);
3006         if (hmin <= 0)
3007                 return;
3008         if (!(p = strsep(&spec, "")) || !*p)
3009                 return;
3010         hmax = 1000 * simple_strtoul(p, NULL, 10);
3011         if (hmax <= 0 || hmax <= hmin)
3012                 return;
3013
3014         fb_info.monspecs.vfmin = vmin;
3015         fb_info.monspecs.vfmax = vmax;
3016         fb_info.monspecs.hfmin = hmin;
3017         fb_info.monspecs.hfmax = hmax;
3018 }
3019 #endif /* ATAFB_FALCON */
3020
3021
3022 static void __init atafb_setup_user(char *spec)
3023 {
3024         /* Format of user defined video mode is: <xres>;<yres>;<depth>
3025          */
3026         char *p;
3027         int xres, yres, depth, temp;
3028
3029         if (!(p = strsep(&spec, ";")) || !*p)
3030                 return;
3031         xres = simple_strtoul(p, NULL, 10);
3032         if (!(p = strsep(&spec, ";")) || !*p)
3033                 return;
3034         yres = simple_strtoul(p, NULL, 10);
3035         if (!(p = strsep(&spec, "")) || !*p)
3036                 return;
3037         depth = simple_strtoul(p, NULL, 10);
3038         if ((temp=get_video_mode("user0"))) {
3039                 default_par=temp;
3040                 atafb_predefined[default_par-1].xres = xres;
3041                 atafb_predefined[default_par-1].yres = yres;
3042                 atafb_predefined[default_par-1].bits_per_pixel = depth;
3043         }
3044 }
3045
3046 int __init atafb_setup( char *options )
3047 {
3048     char *this_opt;
3049     int temp;
3050
3051     fb_info.fontname[0] = '\0';
3052
3053     if (!options || !*options)
3054                 return 0;
3055
3056     while ((this_opt = strsep(&options, ",")) != NULL) {
3057         if (!*this_opt) continue;
3058         if ((temp=get_video_mode(this_opt)))
3059                 default_par=temp;
3060         else if (! strcmp(this_opt, "inverse"))
3061                 inverse=1;
3062         else if (!strncmp(this_opt, "font:", 5))
3063            strcpy(fb_info.fontname, this_opt+5);
3064         else if (! strncmp(this_opt, "hwscroll_",9)) {
3065                 hwscroll=simple_strtoul(this_opt+9, NULL, 10);
3066                 if (hwscroll < 0)
3067                         hwscroll = 0;
3068                 if (hwscroll > 200)
3069                         hwscroll = 200;
3070         }
3071 #ifdef ATAFB_EXT
3072         else if (!strcmp(this_opt,"mv300")) {
3073                 external_bitspercol = 8;
3074                 external_card_type = IS_MV300;
3075         }
3076         else if (!strncmp(this_opt,"external:",9))
3077                 atafb_setup_ext(this_opt+9);
3078 #endif
3079         else if (!strncmp(this_opt,"internal:",9))
3080                 atafb_setup_int(this_opt+9);
3081 #ifdef ATAFB_FALCON
3082         else if (!strncmp(this_opt, "eclock:", 7)) {
3083                 fext.f = simple_strtoul(this_opt+7, NULL, 10);
3084                 /* external pixelclock in kHz --> ps */
3085                 fext.t = 1000000000/fext.f;
3086                 fext.f *= 1000;
3087         }
3088         else if (!strncmp(this_opt, "monitorcap:", 11))
3089                 atafb_setup_mcap(this_opt+11);
3090 #endif
3091         else if (!strcmp(this_opt, "keep"))
3092                 DontCalcRes = 1;
3093         else if (!strncmp(this_opt, "R", 1))
3094                 atafb_setup_user(this_opt+1);
3095     }
3096     return 0;
3097 }
3098
3099 #ifdef MODULE
3100 MODULE_LICENSE("GPL");
3101
3102 int init_module(void)
3103 {
3104         return atafb_init();
3105 }
3106 #endif /* MODULE */