git.oblomov.eu Git - linux-2.6/blob - drivers/video/cirrusfb.c

   1 /*
   2  * drivers/video/cirrusfb.c - driver for Cirrus Logic chipsets
   3  *
   4  * Copyright 1999-2001 Jeff Garzik <jgarzik@pobox.com>
   5  *
   6  * Contributors (thanks, all!)
   7  *
   8  *      David Eger:
   9  *      Overhaul for Linux 2.6
  10  *
  11  *      Jeff Rugen:
  12  *      Major contributions;  Motorola PowerStack (PPC and PCI) support,
  13  *      GD54xx, 1280x1024 mode support, change MCLK based on VCLK.
  14  *
  15  *      Geert Uytterhoeven:
  16  *      Excellent code review.
  17  *
  18  *      Lars Hecking:
  19  *      Amiga updates and testing.
  20  *
  21  * Original cirrusfb author:  Frank Neumann
  22  *
  23  * Based on retz3fb.c and cirrusfb.c:
  24  *      Copyright (C) 1997 Jes Sorensen
  25  *      Copyright (C) 1996 Frank Neumann
  26  *
  27  ***************************************************************
  28  *
  29  * Format this code with GNU indent '-kr -i8 -pcs' options.
  30  *
  31  * This file is subject to the terms and conditions of the GNU General Public
  32  * License.  See the file COPYING in the main directory of this archive
  33  * for more details.
  34  *
  35  */
  36
  37 #define CIRRUSFB_VERSION "2.0-pre2"
  38
  39 #include <linux/config.h>
  40 #include <linux/module.h>
  41 #include <linux/kernel.h>
  42 #include <linux/errno.h>
  43 #include <linux/string.h>
  44 #include <linux/mm.h>
  45 #include <linux/tty.h>
  46 #include <linux/slab.h>
  47 #include <linux/delay.h>
  48 #include <linux/fb.h>
  49 #include <linux/init.h>
  50 #include <linux/selection.h>
  51 #include <asm/pgtable.h>
  52
  53 #ifdef CONFIG_ZORRO
  54 #include <linux/zorro.h>
  55 #endif
  56 #ifdef CONFIG_PCI
  57 #include <linux/pci.h>
  58 #endif
  59 #ifdef CONFIG_AMIGA
  60 #include <asm/amigahw.h>
  61 #endif
  62 #ifdef CONFIG_PPC_PREP
  63 #include <asm/machdep.h>
  64 #define isPReP (machine_is(prep))
  65 #else
  66 #define isPReP 0
  67 #endif
  68
  69 #include "video/vga.h"
  70 #include "video/cirrus.h"
  71
  72
  73 /*****************************************************************
  74  *
  75  * debugging and utility macros
  76  *
  77  */
  78
  79 /* enable debug output? */
  80 /* #define CIRRUSFB_DEBUG 1 */
  81
  82 /* disable runtime assertions? */
  83 /* #define CIRRUSFB_NDEBUG */
  84
  85 /* debug output */
  86 #ifdef CIRRUSFB_DEBUG
  87 #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
  88 #else
  89 #define DPRINTK(fmt, args...)
  90 #endif
  91
  92 /* debugging assertions */
  93 #ifndef CIRRUSFB_NDEBUG
  94 #define assert(expr) \
  95         if(!(expr)) { \
  96         printk( "Assertion failed! %s,%s,%s,line=%d\n",\
  97         #expr,__FILE__,__FUNCTION__,__LINE__); \
  98         }
  99 #else
 100 #define assert(expr)
 101 #endif
 102
 103 #ifdef TRUE
 104 #undef TRUE
 105 #endif
 106 #ifdef FALSE
 107 #undef FALSE
 108 #endif
 109 #define TRUE  1
 110 #define FALSE 0
 111
 112 #define MB_ (1024*1024)
 113 #define KB_ (1024)
 114
 115 #define MAX_NUM_BOARDS 7
 116
 117
 118 /*****************************************************************
 119  *
 120  * chipset information
 121  *
 122  */
 123
 124 /* board types */
 125 typedef enum {
 126         BT_NONE = 0,
 127         BT_SD64,
 128         BT_PICCOLO,
 129         BT_PICASSO,
 130         BT_SPECTRUM,
 131         BT_PICASSO4,    /* GD5446 */
 132         BT_ALPINE,      /* GD543x/4x */
 133         BT_GD5480,
 134         BT_LAGUNA,      /* GD546x */
 135 } cirrusfb_board_t;
 136
 137
 138 /*
 139  * per-board-type information, used for enumerating and abstracting
 140  * chip-specific information
 141  * NOTE: MUST be in the same order as cirrusfb_board_t in order to
 142  * use direct indexing on this array
 143  * NOTE: '__initdata' cannot be used as some of this info
 144  * is required at runtime.  Maybe separate into an init-only and
 145  * a run-time table?
 146  */
 147 static const struct cirrusfb_board_info_rec {
 148         char *name;             /* ASCII name of chipset */
 149         long maxclock[5];               /* maximum video clock */
 150         /* for  1/4bpp, 8bpp 15/16bpp, 24bpp, 32bpp - numbers from xorg code */
 151         unsigned init_sr07 : 1; /* init SR07 during init_vgachip() */
 152         unsigned init_sr1f : 1; /* write SR1F during init_vgachip() */
 153         unsigned scrn_start_bit19 : 1; /* construct bit 19 of screen start address */
 154
 155         /* initial SR07 value, then for each mode */
 156         unsigned char sr07;
 157         unsigned char sr07_1bpp;
 158         unsigned char sr07_1bpp_mux;
 159         unsigned char sr07_8bpp;
 160         unsigned char sr07_8bpp_mux;
 161
 162         unsigned char sr1f;     /* SR1F VGA initial register value */
 163 } cirrusfb_board_info[] = {
 164         [BT_SD64] = {
 165                 .name                   = "CL SD64",
 166                 .maxclock               = {
 167                         /* guess */
 168                         /* the SD64/P4 have a higher max. videoclock */
 169                         140000, 140000, 140000, 140000, 140000,
 170                 },
 171                 .init_sr07              = TRUE,
 172                 .init_sr1f              = TRUE,
 173                 .scrn_start_bit19       = TRUE,
 174                 .sr07                   = 0xF0,
 175                 .sr07_1bpp              = 0xF0,
 176                 .sr07_8bpp              = 0xF1,
 177                 .sr1f                   = 0x20
 178         },
 179         [BT_PICCOLO] = {
 180                 .name                   = "CL Piccolo",
 181                 .maxclock               = {
 182                         /* guess */
 183                         90000, 90000, 90000, 90000, 90000
 184                 },
 185                 .init_sr07              = TRUE,
 186                 .init_sr1f              = TRUE,
 187                 .scrn_start_bit19       = FALSE,
 188                 .sr07                   = 0x80,
 189                 .sr07_1bpp              = 0x80,
 190                 .sr07_8bpp              = 0x81,
 191                 .sr1f                   = 0x22
 192         },
 193         [BT_PICASSO] = {
 194                 .name                   = "CL Picasso",
 195                 .maxclock               = {
 196                         /* guess */
 197                         90000, 90000, 90000, 90000, 90000
 198                 },
 199                 .init_sr07              = TRUE,
 200                 .init_sr1f              = TRUE,
 201                 .scrn_start_bit19       = FALSE,
 202                 .sr07                   = 0x20,
 203                 .sr07_1bpp              = 0x20,
 204                 .sr07_8bpp              = 0x21,
 205                 .sr1f                   = 0x22
 206         },
 207         [BT_SPECTRUM] = {
 208                 .name                   = "CL Spectrum",
 209                 .maxclock               = {
 210                         /* guess */
 211                         90000, 90000, 90000, 90000, 90000
 212                 },
 213                 .init_sr07              = TRUE,
 214                 .init_sr1f              = TRUE,
 215                 .scrn_start_bit19       = FALSE,
 216                 .sr07                   = 0x80,
 217                 .sr07_1bpp              = 0x80,
 218                 .sr07_8bpp              = 0x81,
 219                 .sr1f                   = 0x22
 220         },
 221         [BT_PICASSO4] = {
 222                 .name                   = "CL Picasso4",
 223                 .maxclock               = {
 224                         135100, 135100, 85500, 85500, 0
 225                 },
 226                 .init_sr07              = TRUE,
 227                 .init_sr1f              = FALSE,
 228                 .scrn_start_bit19       = TRUE,
 229                 .sr07                   = 0x20,
 230                 .sr07_1bpp              = 0x20,
 231                 .sr07_8bpp              = 0x21,
 232                 .sr1f                   = 0
 233         },
 234         [BT_ALPINE] = {
 235                 .name                   = "CL Alpine",
 236                 .maxclock               = {
 237                         /* for the GD5430.  GD5446 can do more... */
 238                         85500, 85500, 50000, 28500, 0
 239                 },
 240                 .init_sr07              = TRUE,
 241                 .init_sr1f              = TRUE,
 242                 .scrn_start_bit19       = TRUE,
 243                 .sr07                   = 0xA0,
 244                 .sr07_1bpp              = 0xA1,
 245                 .sr07_1bpp_mux          = 0xA7,
 246                 .sr07_8bpp              = 0xA1,
 247                 .sr07_8bpp_mux          = 0xA7,
 248                 .sr1f                   = 0x1C
 249         },
 250         [BT_GD5480] = {
 251                 .name                   = "CL GD5480",
 252                 .maxclock               = {
 253                         135100, 200000, 200000, 135100, 135100
 254                 },
 255                 .init_sr07              = TRUE,
 256                 .init_sr1f              = TRUE,
 257                 .scrn_start_bit19       = TRUE,
 258                 .sr07                   = 0x10,
 259                 .sr07_1bpp              = 0x11,
 260                 .sr07_8bpp              = 0x11,
 261                 .sr1f                   = 0x1C
 262         },
 263         [BT_LAGUNA] = {
 264                 .name                   = "CL Laguna",
 265                 .maxclock               = {
 266                         /* guess */
 267                         135100, 135100, 135100, 135100, 135100,
 268                 },
 269                 .init_sr07              = FALSE,
 270                 .init_sr1f              = FALSE,
 271                 .scrn_start_bit19       = TRUE,
 272         }
 273 };
 274
 275
 276 #ifdef CONFIG_PCI
 277 #define CHIP(id, btype) \
 278         { PCI_VENDOR_ID_CIRRUS, id, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (btype) }
 279
 280 static struct pci_device_id cirrusfb_pci_table[] = {
 281         CHIP( PCI_DEVICE_ID_CIRRUS_5436, BT_ALPINE ),
 282         CHIP( PCI_DEVICE_ID_CIRRUS_5434_8, BT_ALPINE ),
 283         CHIP( PCI_DEVICE_ID_CIRRUS_5434_4, BT_ALPINE ),
 284         CHIP( PCI_DEVICE_ID_CIRRUS_5430, BT_ALPINE ), /* GD-5440 is same id */
 285         CHIP( PCI_DEVICE_ID_CIRRUS_7543, BT_ALPINE ),
 286         CHIP( PCI_DEVICE_ID_CIRRUS_7548, BT_ALPINE ),
 287         CHIP( PCI_DEVICE_ID_CIRRUS_5480, BT_GD5480 ), /* MacPicasso likely */
 288         CHIP( PCI_DEVICE_ID_CIRRUS_5446, BT_PICASSO4 ), /* Picasso 4 is 5446 */
 289         CHIP( PCI_DEVICE_ID_CIRRUS_5462, BT_LAGUNA ), /* CL Laguna */
 290         CHIP( PCI_DEVICE_ID_CIRRUS_5464, BT_LAGUNA ), /* CL Laguna 3D */
 291         CHIP( PCI_DEVICE_ID_CIRRUS_5465, BT_LAGUNA ), /* CL Laguna 3DA*/
 292         { 0, }
 293 };
 294 MODULE_DEVICE_TABLE(pci, cirrusfb_pci_table);
 295 #undef CHIP
 296 #endif /* CONFIG_PCI */
 297
 298
 299 #ifdef CONFIG_ZORRO
 300 static const struct zorro_device_id cirrusfb_zorro_table[] = {
 301         {
 302                 .id             = ZORRO_PROD_HELFRICH_SD64_RAM,
 303                 .driver_data    = BT_SD64,
 304         }, {
 305                 .id             = ZORRO_PROD_HELFRICH_PICCOLO_RAM,
 306                 .driver_data    = BT_PICCOLO,
 307         }, {
 308                 .id             = ZORRO_PROD_VILLAGE_TRONIC_PICASSO_II_II_PLUS_RAM,
 309                 .driver_data    = BT_PICASSO,
 310         }, {
 311                 .id             = ZORRO_PROD_GVP_EGS_28_24_SPECTRUM_RAM,
 312                 .driver_data    = BT_SPECTRUM,
 313         }, {
 314                 .id             = ZORRO_PROD_VILLAGE_TRONIC_PICASSO_IV_Z3,
 315                 .driver_data    = BT_PICASSO4,
 316         },
 317         { 0 }
 318 };
 319
 320 static const struct {
 321         zorro_id id2;
 322         unsigned long size;
 323 } cirrusfb_zorro_table2[] = {
 324         [BT_SD64] = {
 325                 .id2    = ZORRO_PROD_HELFRICH_SD64_REG,
 326                 .size   = 0x400000
 327         },
 328         [BT_PICCOLO] = {
 329                 .id2    = ZORRO_PROD_HELFRICH_PICCOLO_REG,
 330                 .size   = 0x200000
 331         },
 332         [BT_PICASSO] = {
 333                 .id2    = ZORRO_PROD_VILLAGE_TRONIC_PICASSO_II_II_PLUS_REG,
 334                 .size   = 0x200000
 335         },
 336         [BT_SPECTRUM] = {
 337                 .id2    = ZORRO_PROD_GVP_EGS_28_24_SPECTRUM_REG,
 338                 .size   = 0x200000
 339         },
 340         [BT_PICASSO4] = {
 341                 .id2    = 0,
 342                 .size   = 0x400000
 343         }
 344 };
 345 #endif /* CONFIG_ZORRO */
 346
 347
 348 struct cirrusfb_regs {
 349         __u32 line_length;      /* in BYTES! */
 350         __u32 visual;
 351         __u32 type;
 352
 353         long freq;
 354         long nom;
 355         long den;
 356         long div;
 357         long multiplexing;
 358         long mclk;
 359         long divMCLK;
 360
 361         long HorizRes;          /* The x resolution in pixel */
 362         long HorizTotal;
 363         long HorizDispEnd;
 364         long HorizBlankStart;
 365         long HorizBlankEnd;
 366         long HorizSyncStart;
 367         long HorizSyncEnd;
 368
 369         long VertRes;           /* the physical y resolution in scanlines */
 370         long VertTotal;
 371         long VertDispEnd;
 372         long VertSyncStart;
 373         long VertSyncEnd;
 374         long VertBlankStart;
 375         long VertBlankEnd;
 376 };
 377
 378
 379
 380 #ifdef CIRRUSFB_DEBUG
 381 typedef enum {
 382         CRT,
 383         SEQ
 384 } cirrusfb_dbg_reg_class_t;
 385 #endif                          /* CIRRUSFB_DEBUG */
 386
 387
 388
 389
 390 /* info about board */
 391 struct cirrusfb_info {
 392         struct fb_info *info;
 393
 394         u8 __iomem *fbmem;
 395         u8 __iomem *regbase;
 396         u8 __iomem *mem;
 397         unsigned long size;
 398         cirrusfb_board_t btype;
 399         unsigned char SFR;      /* Shadow of special function register */
 400
 401         unsigned long fbmem_phys;
 402         unsigned long fbregs_phys;
 403
 404         struct cirrusfb_regs currentmode;
 405         int blank_mode;
 406
 407         u32     pseudo_palette[16];
 408         struct { u8 red, green, blue, pad; } palette[256];
 409
 410 #ifdef CONFIG_ZORRO
 411         struct zorro_dev *zdev;
 412 #endif
 413 #ifdef CONFIG_PCI
 414         struct pci_dev *pdev;
 415 #endif
 416         void (*unmap)(struct cirrusfb_info *cinfo);
 417 };
 418
 419
 420 static unsigned cirrusfb_def_mode = 1;
 421 static int noaccel = 0;
 422
 423 /*
 424  *    Predefined Video Modes
 425  */
 426
 427 static const struct {
 428         const char *name;
 429         struct fb_var_screeninfo var;
 430 } cirrusfb_predefined[] = {
 431         {
 432                 /* autodetect mode */
 433                 .name   = "Autodetect",
 434         }, {
 435                 /* 640x480, 31.25 kHz, 60 Hz, 25 MHz PixClock */
 436                 .name   = "640x480",
 437                 .var    = {
 438                         .xres           = 640,
 439                         .yres           = 480,
 440                         .xres_virtual   = 640,
 441                         .yres_virtual   = 480,
 442                         .bits_per_pixel = 8,
 443                         .red            = { .length = 8 },
 444                         .green          = { .length = 8 },
 445                         .blue           = { .length = 8 },
 446                         .width          = -1,
 447                         .height         = -1,
 448                         .pixclock       = 40000,
 449                         .left_margin    = 48,
 450                         .right_margin   = 16,
 451                         .upper_margin   = 32,
 452                         .lower_margin   = 8,
 453                         .hsync_len      = 96,
 454                         .vsync_len      = 4,
 455                         .sync           = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
 456                         .vmode          = FB_VMODE_NONINTERLACED
 457                  }
 458         }, {
 459                 /* 800x600, 48 kHz, 76 Hz, 50 MHz PixClock */
 460                 .name   = "800x600",
 461                 .var    = {
 462                         .xres           = 800,
 463                         .yres           = 600,
 464                         .xres_virtual   = 800,
 465                         .yres_virtual   = 600,
 466                         .bits_per_pixel = 8,
 467                         .red            = { .length = 8 },
 468                         .green          = { .length = 8 },
 469                         .blue           = { .length = 8 },
 470                         .width          = -1,
 471                         .height         = -1,
 472                         .pixclock       = 20000,
 473                         .left_margin    = 128,
 474                         .right_margin   = 16,
 475                         .upper_margin   = 24,
 476                         .lower_margin   = 2,
 477                         .hsync_len      = 96,
 478                         .vsync_len      = 6,
 479                         .vmode          = FB_VMODE_NONINTERLACED
 480                  }
 481         }, {
 482                 /*
 483                  * Modeline from XF86Config:
 484                  * Mode "1024x768" 80  1024 1136 1340 1432  768 770 774 805
 485                  */
 486                 /* 1024x768, 55.8 kHz, 70 Hz, 80 MHz PixClock */
 487                 .name   = "1024x768",
 488                 .var    = {
 489                         .xres           = 1024,
 490                         .yres           = 768,
 491                         .xres_virtual   = 1024,
 492                         .yres_virtual   = 768,
 493                         .bits_per_pixel = 8,
 494                         .red            = { .length = 8 },
 495                         .green          = { .length = 8 },
 496                         .blue           = { .length = 8 },
 497                         .width          = -1,
 498                         .height         = -1,
 499                         .pixclock       = 12500,
 500                         .left_margin    = 144,
 501                         .right_margin   = 32,
 502                         .upper_margin   = 30,
 503                         .lower_margin   = 2,
 504                         .hsync_len      = 192,
 505                         .vsync_len      = 6,
 506                         .vmode          = FB_VMODE_NONINTERLACED
 507                 }
 508         }
 509 };
 510
 511 #define NUM_TOTAL_MODES    ARRAY_SIZE(cirrusfb_predefined)
 512
 513 /****************************************************************************/
 514 /**** BEGIN PROTOTYPES ******************************************************/
 515
 516
 517 /*--- Interface used by the world ------------------------------------------*/
 518 static int cirrusfb_init (void);
 519 #ifndef MODULE
 520 static int cirrusfb_setup (char *options);
 521 #endif
 522
 523 static int cirrusfb_open (struct fb_info *info, int user);
 524 static int cirrusfb_release (struct fb_info *info, int user);
 525 static int cirrusfb_setcolreg (unsigned regno, unsigned red, unsigned green,
 526                                unsigned blue, unsigned transp,
 527                                struct fb_info *info);
 528 static int cirrusfb_check_var (struct fb_var_screeninfo *var,
 529                                struct fb_info *info);
 530 static int cirrusfb_set_par (struct fb_info *info);
 531 static int cirrusfb_pan_display (struct fb_var_screeninfo *var,
 532                                  struct fb_info *info);
 533 static int cirrusfb_blank (int blank_mode, struct fb_info *info);
 534 static void cirrusfb_fillrect (struct fb_info *info, const struct fb_fillrect *region);
 535 static void cirrusfb_copyarea(struct fb_info *info, const struct fb_copyarea *area);
 536 static void cirrusfb_imageblit(struct fb_info *info, const struct fb_image *image);
 537
 538 /* function table of the above functions */
 539 static struct fb_ops cirrusfb_ops = {
 540         .owner          = THIS_MODULE,
 541         .fb_open        = cirrusfb_open,
 542         .fb_release     = cirrusfb_release,
 543         .fb_setcolreg   = cirrusfb_setcolreg,
 544         .fb_check_var   = cirrusfb_check_var,
 545         .fb_set_par     = cirrusfb_set_par,
 546         .fb_pan_display = cirrusfb_pan_display,
 547         .fb_blank       = cirrusfb_blank,
 548         .fb_fillrect    = cirrusfb_fillrect,
 549         .fb_copyarea    = cirrusfb_copyarea,
 550         .fb_imageblit   = cirrusfb_imageblit,
 551 };
 552
 553 /*--- Hardware Specific Routines -------------------------------------------*/
 554 static int cirrusfb_decode_var (const struct fb_var_screeninfo *var,
 555                                 struct cirrusfb_regs *regs,
 556                                 const struct fb_info *info);
 557 /*--- Internal routines ----------------------------------------------------*/
 558 static void init_vgachip (struct cirrusfb_info *cinfo);
 559 static void switch_monitor (struct cirrusfb_info *cinfo, int on);
 560 static void WGen (const struct cirrusfb_info *cinfo,
 561                   int regnum, unsigned char val);
 562 static unsigned char RGen (const struct cirrusfb_info *cinfo, int regnum);
 563 static void AttrOn (const struct cirrusfb_info *cinfo);
 564 static void WHDR (const struct cirrusfb_info *cinfo, unsigned char val);
 565 static void WSFR (struct cirrusfb_info *cinfo, unsigned char val);
 566 static void WSFR2 (struct cirrusfb_info *cinfo, unsigned char val);
 567 static void WClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char red,
 568                    unsigned char green,
 569                    unsigned char blue);
 570 #if 0
 571 static void RClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char *red,
 572                    unsigned char *green,
 573                    unsigned char *blue);
 574 #endif
 575 static void cirrusfb_WaitBLT (u8 __iomem *regbase);
 576 static void cirrusfb_BitBLT (u8 __iomem *regbase, int bits_per_pixel,
 577                              u_short curx, u_short cury,
 578                              u_short destx, u_short desty,
 579                              u_short width, u_short height,
 580                              u_short line_length);
 581 static void cirrusfb_RectFill (u8 __iomem *regbase, int bits_per_pixel,
 582                                u_short x, u_short y,
 583                                u_short width, u_short height,
 584                                u_char color, u_short line_length);
 585
 586 static void bestclock (long freq, long *best,
 587                        long *nom, long *den,
 588                        long *div, long maxfreq);
 589
 590 #ifdef CIRRUSFB_DEBUG
 591 static void cirrusfb_dump (void);
 592 static void cirrusfb_dbg_reg_dump (caddr_t regbase);
 593 static void cirrusfb_dbg_print_regs (caddr_t regbase, cirrusfb_dbg_reg_class_t reg_class,...);
 594 static void cirrusfb_dbg_print_byte (const char *name, unsigned char val);
 595 #endif /* CIRRUSFB_DEBUG */
 596
 597 /*** END   PROTOTYPES ********************************************************/
 598 /*****************************************************************************/
 599 /*** BEGIN Interface Used by the World ***************************************/
 600
 601 static int opencount = 0;
 602
 603 /*--- Open /dev/fbx ---------------------------------------------------------*/
 604 static int cirrusfb_open (struct fb_info *info, int user)
 605 {
 606         if (opencount++ == 0)
 607                 switch_monitor (info->par, 1);
 608         return 0;
 609 }
 610
 611 /*--- Close /dev/fbx --------------------------------------------------------*/
 612 static int cirrusfb_release (struct fb_info *info, int user)
 613 {
 614         if (--opencount == 0)
 615                 switch_monitor (info->par, 0);
 616         return 0;
 617 }
 618
 619 /**** END   Interface used by the World *************************************/
 620 /****************************************************************************/
 621 /**** BEGIN Hardware specific Routines **************************************/
 622
 623 /* Get a good MCLK value */
 624 static long cirrusfb_get_mclk (long freq, int bpp, long *div)
 625 {
 626         long mclk;
 627
 628         assert (div != NULL);
 629
 630         /* Calculate MCLK, in case VCLK is high enough to require > 50MHz.
 631          * Assume a 64-bit data path for now.  The formula is:
 632          * ((B * PCLK * 2)/W) * 1.2
 633          * B = bytes per pixel, PCLK = pixclock, W = data width in bytes */
 634         mclk = ((bpp / 8) * freq * 2) / 4;
 635         mclk = (mclk * 12) / 10;
 636         if (mclk < 50000)
 637                 mclk = 50000;
 638         DPRINTK ("Use MCLK of %ld kHz\n", mclk);
 639
 640         /* Calculate value for SR1F.  Multiply by 2 so we can round up. */
 641         mclk = ((mclk * 16) / 14318);
 642         mclk = (mclk + 1) / 2;
 643         DPRINTK ("Set SR1F[5:0] to 0x%lx\n", mclk);
 644
 645         /* Determine if we should use MCLK instead of VCLK, and if so, what we
 646            * should divide it by to get VCLK */
 647         switch (freq) {
 648         case 24751 ... 25249:
 649                 *div = 2;
 650                 DPRINTK ("Using VCLK = MCLK/2\n");
 651                 break;
 652         case 49501 ... 50499:
 653                 *div = 1;
 654                 DPRINTK ("Using VCLK = MCLK\n");
 655                 break;
 656         default:
 657                 *div = 0;
 658                 break;
 659         }
 660
 661         return mclk;
 662 }
 663
 664 static int cirrusfb_check_var(struct fb_var_screeninfo *var,
 665                               struct fb_info *info)
 666 {
 667         struct cirrusfb_info *cinfo = info->par;
 668         int nom, den;           /* translyting from pixels->bytes */
 669         int yres, i;
 670         static struct { int xres, yres; } modes[] =
 671         { { 1600, 1280 },
 672           { 1280, 1024 },
 673           { 1024, 768 },
 674           { 800, 600 },
 675           { 640, 480 },
 676           { -1, -1 } };
 677
 678         switch (var->bits_per_pixel) {
 679         case 0 ... 1:
 680                 var->bits_per_pixel = 1;
 681                 nom = 4;
 682                 den = 8;
 683                 break;          /* 8 pixel per byte, only 1/4th of mem usable */
 684         case 2 ... 8:
 685                 var->bits_per_pixel = 8;
 686                 nom = 1;
 687                 den = 1;
 688                 break;          /* 1 pixel == 1 byte */
 689         case 9 ... 16:
 690                 var->bits_per_pixel = 16;
 691                 nom = 2;
 692                 den = 1;
 693                 break;          /* 2 bytes per pixel */
 694         case 17 ... 24:
 695                 var->bits_per_pixel = 24;
 696                 nom = 3;
 697                 den = 1;
 698                 break;          /* 3 bytes per pixel */
 699         case 25 ... 32:
 700                 var->bits_per_pixel = 32;
 701                 nom = 4;
 702                 den = 1;
 703                 break;          /* 4 bytes per pixel */
 704         default:
 705                 printk ("cirrusfb: mode %dx%dx%d rejected...color depth not supported.\n",
 706                         var->xres, var->yres, var->bits_per_pixel);
 707                 DPRINTK ("EXIT - EINVAL error\n");
 708                 return -EINVAL;
 709         }
 710
 711         if (var->xres * nom / den * var->yres > cinfo->size) {
 712                 printk ("cirrusfb: mode %dx%dx%d rejected...resolution too high to fit into video memory!\n",
 713                         var->xres, var->yres, var->bits_per_pixel);
 714                 DPRINTK ("EXIT - EINVAL error\n");
 715                 return -EINVAL;
 716         }
 717
 718         /* use highest possible virtual resolution */
 719         if (var->xres_virtual == -1 &&
 720             var->yres_virtual == -1) {
 721                 printk ("cirrusfb: using maximum available virtual resolution\n");
 722                 for (i = 0; modes[i].xres != -1; i++) {
 723                         if (modes[i].xres * nom / den * modes[i].yres < cinfo->size / 2)
 724                                 break;
 725                 }
 726                 if (modes[i].xres == -1) {
 727                         printk ("cirrusfb: could not find a virtual resolution that fits into video memory!!\n");
 728                         DPRINTK ("EXIT - EINVAL error\n");
 729                         return -EINVAL;
 730                 }
 731                 var->xres_virtual = modes[i].xres;
 732                 var->yres_virtual = modes[i].yres;
 733
 734                 printk ("cirrusfb: virtual resolution set to maximum of %dx%d\n",
 735                         var->xres_virtual, var->yres_virtual);
 736         }
 737
 738         if (var->xres_virtual < var->xres)
 739                 var->xres_virtual = var->xres;
 740         if (var->yres_virtual < var->yres)
 741                 var->yres_virtual = var->yres;
 742
 743         if (var->xoffset < 0)
 744                 var->xoffset = 0;
 745         if (var->yoffset < 0)
 746                 var->yoffset = 0;
 747
 748         /* truncate xoffset and yoffset to maximum if too high */
 749         if (var->xoffset > var->xres_virtual - var->xres)
 750                 var->xoffset = var->xres_virtual - var->xres - 1;
 751         if (var->yoffset > var->yres_virtual - var->yres)
 752                 var->yoffset = var->yres_virtual - var->yres - 1;
 753
 754         switch (var->bits_per_pixel) {
 755         case 1:
 756                 var->red.offset = 0;
 757                 var->red.length = 1;
 758                 var->green.offset = 0;
 759                 var->green.length = 1;
 760                 var->blue.offset = 0;
 761                 var->blue.length = 1;
 762                 break;
 763
 764         case 8:
 765                 var->red.offset = 0;
 766                 var->red.length = 6;
 767                 var->green.offset = 0;
 768                 var->green.length = 6;
 769                 var->blue.offset = 0;
 770                 var->blue.length = 6;
 771                 break;
 772
 773         case 16:
 774                 if(isPReP) {
 775                         var->red.offset = 2;
 776                         var->green.offset = -3;
 777                         var->blue.offset = 8;
 778                 } else {
 779                         var->red.offset = 10;
 780                         var->green.offset = 5;
 781                         var->blue.offset = 0;
 782                 }
 783                 var->red.length = 5;
 784                 var->green.length = 5;
 785                 var->blue.length = 5;
 786                 break;
 787
 788         case 24:
 789                 if(isPReP) {
 790                         var->red.offset = 8;
 791                         var->green.offset = 16;
 792                         var->blue.offset = 24;
 793                 } else {
 794                         var->red.offset = 16;
 795                         var->green.offset = 8;
 796                         var->blue.offset = 0;
 797                 }
 798                 var->red.length = 8;
 799                 var->green.length = 8;
 800                 var->blue.length = 8;
 801                 break;
 802
 803         case 32:
 804                 if(isPReP) {
 805                         var->red.offset = 8;
 806                         var->green.offset = 16;
 807                         var->blue.offset = 24;
 808                 } else {
 809                         var->red.offset = 16;
 810                         var->green.offset = 8;
 811                         var->blue.offset = 0;
 812                 }
 813                 var->red.length = 8;
 814                 var->green.length = 8;
 815                 var->blue.length = 8;
 816                 break;
 817
 818         default:
 819                 DPRINTK("Unsupported bpp size: %d\n", var->bits_per_pixel);
 820                 assert (FALSE);
 821                 /* should never occur */
 822                 break;
 823         }
 824
 825         var->red.msb_right =
 826             var->green.msb_right =
 827             var->blue.msb_right =
 828             var->transp.offset =
 829             var->transp.length =
 830             var->transp.msb_right = 0;
 831
 832         yres = var->yres;
 833         if (var->vmode & FB_VMODE_DOUBLE)
 834                 yres *= 2;
 835         else if (var->vmode & FB_VMODE_INTERLACED)
 836                 yres = (yres + 1) / 2;
 837
 838         if (yres >= 1280) {
 839                 printk (KERN_WARNING "cirrusfb: ERROR: VerticalTotal >= 1280; special treatment required! (TODO)\n");
 840                 DPRINTK ("EXIT - EINVAL error\n");
 841                 return -EINVAL;
 842         }
 843
 844         return 0;
 845 }
 846
 847 static int cirrusfb_decode_var (const struct fb_var_screeninfo *var,
 848                                 struct cirrusfb_regs *regs,
 849                                 const struct fb_info *info)
 850 {
 851         long freq;
 852         long maxclock;
 853         int maxclockidx = 0;
 854         struct cirrusfb_info *cinfo = info->par;
 855         int xres, hfront, hsync, hback;
 856         int yres, vfront, vsync, vback;
 857
 858         switch(var->bits_per_pixel) {
 859         case 1:
 860                 regs->line_length = var->xres_virtual / 8;
 861                 regs->visual = FB_VISUAL_MONO10;
 862                 maxclockidx = 0;
 863                 break;
 864
 865         case 8:
 866                 regs->line_length = var->xres_virtual;
 867                 regs->visual = FB_VISUAL_PSEUDOCOLOR;
 868                 maxclockidx = 1;
 869                 break;
 870
 871         case 16:
 872                 regs->line_length = var->xres_virtual * 2;
 873                 regs->visual = FB_VISUAL_DIRECTCOLOR;
 874                 maxclockidx = 2;
 875                 break;
 876
 877         case 24:
 878                 regs->line_length = var->xres_virtual * 3;
 879                 regs->visual = FB_VISUAL_DIRECTCOLOR;
 880                 maxclockidx = 3;
 881                 break;
 882
 883         case 32:
 884                 regs->line_length = var->xres_virtual * 4;
 885                 regs->visual = FB_VISUAL_DIRECTCOLOR;
 886                 maxclockidx = 4;
 887                 break;
 888
 889         default:
 890                 DPRINTK("Unsupported bpp size: %d\n", var->bits_per_pixel);
 891                 assert (FALSE);
 892                 /* should never occur */
 893                 break;
 894         }
 895
 896         regs->type = FB_TYPE_PACKED_PIXELS;
 897
 898         /* convert from ps to kHz */
 899         freq = 1000000000 / var->pixclock;
 900
 901         DPRINTK ("desired pixclock: %ld kHz\n", freq);
 902
 903         maxclock = cirrusfb_board_info[cinfo->btype].maxclock[maxclockidx];
 904         regs->multiplexing = 0;
 905
 906         /* If the frequency is greater than we can support, we might be able
 907          * to use multiplexing for the video mode */
 908         if (freq > maxclock) {
 909                 switch (cinfo->btype) {
 910                 case BT_ALPINE:
 911                 case BT_GD5480:
 912                         regs->multiplexing = 1;
 913                         break;
 914
 915                 default:
 916                         printk (KERN_WARNING "cirrusfb: ERROR: Frequency greater than maxclock (%ld kHz)\n", maxclock);
 917                         DPRINTK ("EXIT - return -EINVAL\n");
 918                         return -EINVAL;
 919                 }
 920         }
 921 #if 0
 922         /* TODO: If we have a 1MB 5434, we need to put ourselves in a mode where
 923          * the VCLK is double the pixel clock. */
 924         switch (var->bits_per_pixel) {
 925         case 16:
 926         case 32:
 927                 if (regs->HorizRes <= 800)
 928                         freq /= 2;      /* Xbh has this type of clock for 32-bit */
 929                 break;
 930         }
 931 #endif
 932
 933         bestclock (freq, &regs->freq, &regs->nom, &regs->den, &regs->div,
 934                    maxclock);
 935         regs->mclk = cirrusfb_get_mclk (freq, var->bits_per_pixel, &regs->divMCLK);
 936
 937         xres = var->xres;
 938         hfront = var->right_margin;
 939         hsync = var->hsync_len;
 940         hback = var->left_margin;
 941
 942         yres = var->yres;
 943         vfront = var->lower_margin;
 944         vsync = var->vsync_len;
 945         vback = var->upper_margin;
 946
 947         if (var->vmode & FB_VMODE_DOUBLE) {
 948                 yres *= 2;
 949                 vfront *= 2;
 950                 vsync *= 2;
 951                 vback *= 2;
 952         } else if (var->vmode & FB_VMODE_INTERLACED) {
 953                 yres = (yres + 1) / 2;
 954                 vfront = (vfront + 1) / 2;
 955                 vsync = (vsync + 1) / 2;
 956                 vback = (vback + 1) / 2;
 957         }
 958         regs->HorizRes = xres;
 959         regs->HorizTotal = (xres + hfront + hsync + hback) / 8 - 5;
 960         regs->HorizDispEnd = xres / 8 - 1;
 961         regs->HorizBlankStart = xres / 8;
 962         regs->HorizBlankEnd = regs->HorizTotal + 5;     /* does not count with "-5" */
 963         regs->HorizSyncStart = (xres + hfront) / 8 + 1;
 964         regs->HorizSyncEnd = (xres + hfront + hsync) / 8 + 1;
 965
 966         regs->VertRes = yres;
 967         regs->VertTotal = yres + vfront + vsync + vback - 2;
 968         regs->VertDispEnd = yres - 1;
 969         regs->VertBlankStart = yres;
 970         regs->VertBlankEnd = regs->VertTotal;
 971         regs->VertSyncStart = yres + vfront - 1;
 972         regs->VertSyncEnd = yres + vfront + vsync - 1;
 973
 974         if (regs->VertRes >= 1024) {
 975                 regs->VertTotal /= 2;
 976                 regs->VertSyncStart /= 2;
 977                 regs->VertSyncEnd /= 2;
 978                 regs->VertDispEnd /= 2;
 979         }
 980         if (regs->multiplexing) {
 981                 regs->HorizTotal /= 2;
 982                 regs->HorizSyncStart /= 2;
 983                 regs->HorizSyncEnd /= 2;
 984                 regs->HorizDispEnd /= 2;
 985         }
 986
 987         return 0;
 988 }
 989
 990
 991 static void cirrusfb_set_mclk (const struct cirrusfb_info *cinfo, int val, int div)
 992 {
 993         assert (cinfo != NULL);
 994
 995         if (div == 2) {
 996                 /* VCLK = MCLK/2 */
 997                 unsigned char old = vga_rseq (cinfo->regbase, CL_SEQR1E);
 998                 vga_wseq (cinfo->regbase, CL_SEQR1E, old | 0x1);
 999                 vga_wseq (cinfo->regbase, CL_SEQR1F, 0x40 | (val & 0x3f));
1000         } else if (div == 1) {
1001                 /* VCLK = MCLK */
1002                 unsigned char old = vga_rseq (cinfo->regbase, CL_SEQR1E);
1003                 vga_wseq (cinfo->regbase, CL_SEQR1E, old & ~0x1);
1004                 vga_wseq (cinfo->regbase, CL_SEQR1F, 0x40 | (val & 0x3f));
1005         } else {
1006                 vga_wseq (cinfo->regbase, CL_SEQR1F, val & 0x3f);
1007         }
1008 }
1009
1010 /*************************************************************************
1011         cirrusfb_set_par_foo()
1012
1013         actually writes the values for a new video mode into the hardware,
1014 **************************************************************************/
1015 static int cirrusfb_set_par_foo (struct fb_info *info)
1016 {
1017         struct cirrusfb_info *cinfo = info->par;
1018         struct fb_var_screeninfo *var = &info->var;
1019         struct cirrusfb_regs regs;
1020         u8 __iomem *regbase = cinfo->regbase;
1021         unsigned char tmp;
1022         int offset = 0, err;
1023         const struct cirrusfb_board_info_rec *bi;
1024
1025         DPRINTK ("ENTER\n");
1026         DPRINTK ("Requested mode: %dx%dx%d\n",
1027                var->xres, var->yres, var->bits_per_pixel);
1028         DPRINTK ("pixclock: %d\n", var->pixclock);
1029
1030         init_vgachip (cinfo);
1031
1032         err = cirrusfb_decode_var(var, &regs, info);
1033         if(err) {
1034                 /* should never happen */
1035                 DPRINTK("mode change aborted.  invalid var.\n");
1036                 return -EINVAL;
1037         }
1038
1039         bi = &cirrusfb_board_info[cinfo->btype];
1040
1041
1042         /* unlock register VGA_CRTC_H_TOTAL..CRT7 */
1043         vga_wcrt (regbase, VGA_CRTC_V_SYNC_END, 0x20);  /* previously: 0x00) */
1044
1045         /* if debugging is enabled, all parameters get output before writing */
1046         DPRINTK ("CRT0: %ld\n", regs.HorizTotal);
1047         vga_wcrt (regbase, VGA_CRTC_H_TOTAL, regs.HorizTotal);
1048
1049         DPRINTK ("CRT1: %ld\n", regs.HorizDispEnd);
1050         vga_wcrt (regbase, VGA_CRTC_H_DISP, regs.HorizDispEnd);
1051
1052         DPRINTK ("CRT2: %ld\n", regs.HorizBlankStart);
1053         vga_wcrt (regbase, VGA_CRTC_H_BLANK_START, regs.HorizBlankStart);
1054
1055         DPRINTK ("CRT3: 128+%ld\n", regs.HorizBlankEnd % 32);   /*  + 128: Compatible read */
1056         vga_wcrt (regbase, VGA_CRTC_H_BLANK_END, 128 + (regs.HorizBlankEnd % 32));
1057
1058         DPRINTK ("CRT4: %ld\n", regs.HorizSyncStart);
1059         vga_wcrt (regbase, VGA_CRTC_H_SYNC_START, regs.HorizSyncStart);
1060
1061         tmp = regs.HorizSyncEnd % 32;
1062         if (regs.HorizBlankEnd & 32)
1063                 tmp += 128;
1064         DPRINTK ("CRT5: %d\n", tmp);
1065         vga_wcrt (regbase, VGA_CRTC_H_SYNC_END, tmp);
1066
1067         DPRINTK ("CRT6: %ld\n", regs.VertTotal & 0xff);
1068         vga_wcrt (regbase, VGA_CRTC_V_TOTAL, (regs.VertTotal & 0xff));
1069
1070         tmp = 16;               /* LineCompare bit #9 */
1071         if (regs.VertTotal & 256)
1072                 tmp |= 1;
1073         if (regs.VertDispEnd & 256)
1074                 tmp |= 2;
1075         if (regs.VertSyncStart & 256)
1076                 tmp |= 4;
1077         if (regs.VertBlankStart & 256)
1078                 tmp |= 8;
1079         if (regs.VertTotal & 512)
1080                 tmp |= 32;
1081         if (regs.VertDispEnd & 512)
1082                 tmp |= 64;
1083         if (regs.VertSyncStart & 512)
1084                 tmp |= 128;
1085         DPRINTK ("CRT7: %d\n", tmp);
1086         vga_wcrt (regbase, VGA_CRTC_OVERFLOW, tmp);
1087
1088         tmp = 0x40;             /* LineCompare bit #8 */
1089         if (regs.VertBlankStart & 512)
1090                 tmp |= 0x20;
1091         if (var->vmode & FB_VMODE_DOUBLE)
1092                 tmp |= 0x80;
1093         DPRINTK ("CRT9: %d\n", tmp);
1094         vga_wcrt (regbase, VGA_CRTC_MAX_SCAN, tmp);
1095
1096         DPRINTK ("CRT10: %ld\n", regs.VertSyncStart & 0xff);
1097         vga_wcrt (regbase, VGA_CRTC_V_SYNC_START, (regs.VertSyncStart & 0xff));
1098
1099         DPRINTK ("CRT11: 64+32+%ld\n", regs.VertSyncEnd % 16);
1100         vga_wcrt (regbase, VGA_CRTC_V_SYNC_END, (regs.VertSyncEnd % 16 + 64 + 32));
1101
1102         DPRINTK ("CRT12: %ld\n", regs.VertDispEnd & 0xff);
1103         vga_wcrt (regbase, VGA_CRTC_V_DISP_END, (regs.VertDispEnd & 0xff));
1104
1105         DPRINTK ("CRT15: %ld\n", regs.VertBlankStart & 0xff);
1106         vga_wcrt (regbase, VGA_CRTC_V_BLANK_START, (regs.VertBlankStart & 0xff));
1107
1108         DPRINTK ("CRT16: %ld\n", regs.VertBlankEnd & 0xff);
1109         vga_wcrt (regbase, VGA_CRTC_V_BLANK_END, (regs.VertBlankEnd & 0xff));
1110
1111         DPRINTK ("CRT18: 0xff\n");
1112         vga_wcrt (regbase, VGA_CRTC_LINE_COMPARE, 0xff);
1113
1114         tmp = 0;
1115         if (var->vmode & FB_VMODE_INTERLACED)
1116                 tmp |= 1;
1117         if (regs.HorizBlankEnd & 64)
1118                 tmp |= 16;
1119         if (regs.HorizBlankEnd & 128)
1120                 tmp |= 32;
1121         if (regs.VertBlankEnd & 256)
1122                 tmp |= 64;
1123         if (regs.VertBlankEnd & 512)
1124                 tmp |= 128;
1125
1126         DPRINTK ("CRT1a: %d\n", tmp);
1127         vga_wcrt (regbase, CL_CRT1A, tmp);
1128
1129         /* set VCLK0 */
1130         /* hardware RefClock: 14.31818 MHz */
1131         /* formula: VClk = (OSC * N) / (D * (1+P)) */
1132         /* Example: VClk = (14.31818 * 91) / (23 * (1+1)) = 28.325 MHz */
1133
1134         vga_wseq (regbase, CL_SEQRB, regs.nom);
1135         tmp = regs.den << 1;
1136         if (regs.div != 0)
1137                 tmp |= 1;
1138
1139         if ((cinfo->btype == BT_SD64) ||
1140             (cinfo->btype == BT_ALPINE) ||
1141             (cinfo->btype == BT_GD5480))
1142                 tmp |= 0x80;    /* 6 bit denom; ONLY 5434!!! (bugged me 10 days) */
1143
1144         DPRINTK ("CL_SEQR1B: %ld\n", (long) tmp);
1145         vga_wseq (regbase, CL_SEQR1B, tmp);
1146
1147         if (regs.VertRes >= 1024)
1148                 /* 1280x1024 */
1149                 vga_wcrt (regbase, VGA_CRTC_MODE, 0xc7);
1150         else
1151                 /* mode control: VGA_CRTC_START_HI enable, ROTATE(?), 16bit
1152                  * address wrap, no compat. */
1153                 vga_wcrt (regbase, VGA_CRTC_MODE, 0xc3);
1154
1155 /* HAEH?        vga_wcrt (regbase, VGA_CRTC_V_SYNC_END, 0x20);  * previously: 0x00  unlock VGA_CRTC_H_TOTAL..CRT7 */
1156
1157         /* don't know if it would hurt to also program this if no interlaced */
1158         /* mode is used, but I feel better this way.. :-) */
1159         if (var->vmode & FB_VMODE_INTERLACED)
1160                 vga_wcrt (regbase, VGA_CRTC_REGS, regs.HorizTotal / 2);
1161         else
1162                 vga_wcrt (regbase, VGA_CRTC_REGS, 0x00);        /* interlace control */
1163
1164         vga_wseq (regbase, VGA_SEQ_CHARACTER_MAP, 0);
1165
1166         /* adjust horizontal/vertical sync type (low/high) */
1167         tmp = 0x03;             /* enable display memory & CRTC I/O address for color mode */
1168         if (var->sync & FB_SYNC_HOR_HIGH_ACT)
1169                 tmp |= 0x40;
1170         if (var->sync & FB_SYNC_VERT_HIGH_ACT)
1171                 tmp |= 0x80;
1172         WGen (cinfo, VGA_MIS_W, tmp);
1173
1174         vga_wcrt (regbase, VGA_CRTC_PRESET_ROW, 0);     /* Screen A Preset Row-Scan register */
1175         vga_wcrt (regbase, VGA_CRTC_CURSOR_START, 0);   /* text cursor on and start line */
1176         vga_wcrt (regbase, VGA_CRTC_CURSOR_END, 31);    /* text cursor end line */
1177
1178         /******************************************************
1179          *
1180          * 1 bpp
1181          *
1182          */
1183
1184         /* programming for different color depths */
1185         if (var->bits_per_pixel == 1) {
1186                 DPRINTK ("cirrusfb: preparing for 1 bit deep display\n");
1187                 vga_wgfx (regbase, VGA_GFX_MODE, 0);    /* mode register */
1188
1189                 /* SR07 */
1190                 switch (cinfo->btype) {
1191                 case BT_SD64:
1192                 case BT_PICCOLO:
1193                 case BT_PICASSO:
1194                 case BT_SPECTRUM:
1195                 case BT_PICASSO4:
1196                 case BT_ALPINE:
1197                 case BT_GD5480:
1198                         DPRINTK (" (for GD54xx)\n");
1199                         vga_wseq (regbase, CL_SEQR7,
1200                                   regs.multiplexing ?
1201                                         bi->sr07_1bpp_mux : bi->sr07_1bpp);
1202                         break;
1203
1204                 case BT_LAGUNA:
1205                         DPRINTK (" (for GD546x)\n");
1206                         vga_wseq (regbase, CL_SEQR7,
1207                                 vga_rseq (regbase, CL_SEQR7) & ~0x01);
1208                         break;
1209
1210                 default:
1211                         printk (KERN_WARNING "cirrusfb: unknown Board\n");
1212                         break;
1213                 }
1214
1215                 /* Extended Sequencer Mode */
1216                 switch (cinfo->btype) {
1217                 case BT_SD64:
1218                         /* setting the SEQRF on SD64 is not necessary (only during init) */
1219                         DPRINTK ("(for SD64)\n");
1220                         vga_wseq (regbase, CL_SEQR1F, 0x1a);            /*  MCLK select */
1221                         break;
1222
1223                 case BT_PICCOLO:
1224                         DPRINTK ("(for Piccolo)\n");
1225 /* ### ueberall 0x22? */
1226                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* ##vorher 1c MCLK select */
1227                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* evtl d0 bei 1 bit? avoid FIFO underruns..? */
1228                         break;
1229
1230                 case BT_PICASSO:
1231                         DPRINTK ("(for Picasso)\n");
1232                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* ##vorher 22 MCLK select */
1233                         vga_wseq (regbase, CL_SEQRF, 0xd0);     /* ## vorher d0 avoid FIFO underruns..? */
1234                         break;
1235
1236                 case BT_SPECTRUM:
1237                         DPRINTK ("(for Spectrum)\n");
1238 /* ### ueberall 0x22? */
1239                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* ##vorher 1c MCLK select */
1240                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* evtl d0? avoid FIFO underruns..? */
1241                         break;
1242
1243                 case BT_PICASSO4:
1244                 case BT_ALPINE:
1245                 case BT_GD5480:
1246                 case BT_LAGUNA:
1247                         DPRINTK (" (for GD54xx)\n");
1248                         /* do nothing */
1249                         break;
1250
1251                 default:
1252                         printk (KERN_WARNING "cirrusfb: unknown Board\n");
1253                         break;
1254                 }
1255
1256                 WGen (cinfo, VGA_PEL_MSK, 0x01);        /* pixel mask: pass-through for first plane */
1257                 if (regs.multiplexing)
1258                         WHDR (cinfo, 0x4a);     /* hidden dac reg: 1280x1024 */
1259                 else
1260                         WHDR (cinfo, 0);        /* hidden dac: nothing */
1261                 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x06);  /* memory mode: odd/even, ext. memory */
1262                 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0x01);  /* plane mask: only write to first plane */
1263                 offset = var->xres_virtual / 16;
1264         }
1265
1266         /******************************************************
1267          *
1268          * 8 bpp
1269          *
1270          */
1271
1272         else if (var->bits_per_pixel == 8) {
1273                 DPRINTK ("cirrusfb: preparing for 8 bit deep display\n");
1274                 switch (cinfo->btype) {
1275                 case BT_SD64:
1276                 case BT_PICCOLO:
1277                 case BT_PICASSO:
1278                 case BT_SPECTRUM:
1279                 case BT_PICASSO4:
1280                 case BT_ALPINE:
1281                 case BT_GD5480:
1282                         DPRINTK (" (for GD54xx)\n");
1283                         vga_wseq (regbase, CL_SEQR7,
1284                                   regs.multiplexing ?
1285                                         bi->sr07_8bpp_mux : bi->sr07_8bpp);
1286                         break;
1287
1288                 case BT_LAGUNA:
1289                         DPRINTK (" (for GD546x)\n");
1290                         vga_wseq (regbase, CL_SEQR7,
1291                                 vga_rseq (regbase, CL_SEQR7) | 0x01);
1292                         break;
1293
1294                 default:
1295                         printk (KERN_WARNING "cirrusfb: unknown Board\n");
1296                         break;
1297                 }
1298
1299                 switch (cinfo->btype) {
1300                 case BT_SD64:
1301                         vga_wseq (regbase, CL_SEQR1F, 0x1d);            /* MCLK select */
1302                         break;
1303
1304                 case BT_PICCOLO:
1305                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* ### vorher 1c MCLK select */
1306                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1307                         break;
1308
1309                 case BT_PICASSO:
1310                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* ### vorher 1c MCLK select */
1311                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1312                         break;
1313
1314                 case BT_SPECTRUM:
1315                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* ### vorher 1c MCLK select */
1316                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1317                         break;
1318
1319                 case BT_PICASSO4:
1320 #ifdef CONFIG_ZORRO
1321                         vga_wseq (regbase, CL_SEQRF, 0xb8);     /* ### INCOMPLETE!! */
1322 #endif
1323 /*          vga_wseq (regbase, CL_SEQR1F, 0x1c); */
1324                         break;
1325
1326                 case BT_ALPINE:
1327                         DPRINTK (" (for GD543x)\n");
1328                         cirrusfb_set_mclk (cinfo, regs.mclk, regs.divMCLK);
1329                         /* We already set SRF and SR1F */
1330                         break;
1331
1332                 case BT_GD5480:
1333                 case BT_LAGUNA:
1334                         DPRINTK (" (for GD54xx)\n");
1335                         /* do nothing */
1336                         break;
1337
1338                 default:
1339                         printk (KERN_WARNING "cirrusfb: unknown Board\n");
1340                         break;
1341                 }
1342
1343                 vga_wgfx (regbase, VGA_GFX_MODE, 64);   /* mode register: 256 color mode */
1344                 WGen (cinfo, VGA_PEL_MSK, 0xff);        /* pixel mask: pass-through all planes */
1345                 if (regs.multiplexing)
1346                         WHDR (cinfo, 0x4a);     /* hidden dac reg: 1280x1024 */
1347                 else
1348                         WHDR (cinfo, 0);        /* hidden dac: nothing */
1349                 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x0a);  /* memory mode: chain4, ext. memory */
1350                 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0xff);  /* plane mask: enable writing to all 4 planes */
1351                 offset = var->xres_virtual / 8;
1352         }
1353
1354         /******************************************************
1355          *
1356          * 16 bpp
1357          *
1358          */
1359
1360         else if (var->bits_per_pixel == 16) {
1361                 DPRINTK ("cirrusfb: preparing for 16 bit deep display\n");
1362                 switch (cinfo->btype) {
1363                 case BT_SD64:
1364                         vga_wseq (regbase, CL_SEQR7, 0xf7);     /* Extended Sequencer Mode: 256c col. mode */
1365                         vga_wseq (regbase, CL_SEQR1F, 0x1e);            /* MCLK select */
1366                         break;
1367
1368                 case BT_PICCOLO:
1369                         vga_wseq (regbase, CL_SEQR7, 0x87);
1370                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1371                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* MCLK select */
1372                         break;
1373
1374                 case BT_PICASSO:
1375                         vga_wseq (regbase, CL_SEQR7, 0x27);
1376                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1377                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* MCLK select */
1378                         break;
1379
1380                 case BT_SPECTRUM:
1381                         vga_wseq (regbase, CL_SEQR7, 0x87);
1382                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1383                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* MCLK select */
1384                         break;
1385
1386                 case BT_PICASSO4:
1387                         vga_wseq (regbase, CL_SEQR7, 0x27);
1388 /*          vga_wseq (regbase, CL_SEQR1F, 0x1c);  */
1389                         break;
1390
1391                 case BT_ALPINE:
1392                         DPRINTK (" (for GD543x)\n");
1393                         if (regs.HorizRes >= 1024)
1394                                 vga_wseq (regbase, CL_SEQR7, 0xa7);
1395                         else
1396                                 vga_wseq (regbase, CL_SEQR7, 0xa3);
1397                         cirrusfb_set_mclk (cinfo, regs.mclk, regs.divMCLK);
1398                         break;
1399
1400                 case BT_GD5480:
1401                         DPRINTK (" (for GD5480)\n");
1402                         vga_wseq (regbase, CL_SEQR7, 0x17);
1403                         /* We already set SRF and SR1F */
1404                         break;
1405
1406                 case BT_LAGUNA:
1407                         DPRINTK (" (for GD546x)\n");
1408                         vga_wseq (regbase, CL_SEQR7,
1409                                 vga_rseq (regbase, CL_SEQR7) & ~0x01);
1410                         break;
1411
1412                 default:
1413                         printk (KERN_WARNING "CIRRUSFB: unknown Board\n");
1414                         break;
1415                 }
1416
1417                 vga_wgfx (regbase, VGA_GFX_MODE, 64);   /* mode register: 256 color mode */
1418                 WGen (cinfo, VGA_PEL_MSK, 0xff);        /* pixel mask: pass-through all planes */
1419 #ifdef CONFIG_PCI
1420                 WHDR (cinfo, 0xc0);     /* Copy Xbh */
1421 #elif defined(CONFIG_ZORRO)
1422                 /* FIXME: CONFIG_PCI and CONFIG_ZORRO may be defined both */
1423                 WHDR (cinfo, 0xa0);     /* hidden dac reg: nothing special */
1424 #endif
1425                 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x0a);  /* memory mode: chain4, ext. memory */
1426                 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0xff);  /* plane mask: enable writing to all 4 planes */
1427                 offset = var->xres_virtual / 4;
1428         }
1429
1430         /******************************************************
1431          *
1432          * 32 bpp
1433          *
1434          */
1435
1436         else if (var->bits_per_pixel == 32) {
1437                 DPRINTK ("cirrusfb: preparing for 24/32 bit deep display\n");
1438                 switch (cinfo->btype) {
1439                 case BT_SD64:
1440                         vga_wseq (regbase, CL_SEQR7, 0xf9);     /* Extended Sequencer Mode: 256c col. mode */
1441                         vga_wseq (regbase, CL_SEQR1F, 0x1e);            /* MCLK select */
1442                         break;
1443
1444                 case BT_PICCOLO:
1445                         vga_wseq (regbase, CL_SEQR7, 0x85);
1446                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1447                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* MCLK select */
1448                         break;
1449
1450                 case BT_PICASSO:
1451                         vga_wseq (regbase, CL_SEQR7, 0x25);
1452                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1453                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* MCLK select */
1454                         break;
1455
1456                 case BT_SPECTRUM:
1457                         vga_wseq (regbase, CL_SEQR7, 0x85);
1458                         vga_wseq (regbase, CL_SEQRF, 0xb0);     /* Fast Page-Mode writes */
1459                         vga_wseq (regbase, CL_SEQR1F, 0x22);            /* MCLK select */
1460                         break;
1461
1462                 case BT_PICASSO4:
1463                         vga_wseq (regbase, CL_SEQR7, 0x25);
1464 /*          vga_wseq (regbase, CL_SEQR1F, 0x1c);  */
1465                         break;
1466
1467                 case BT_ALPINE:
1468                         DPRINTK (" (for GD543x)\n");
1469                         vga_wseq (regbase, CL_SEQR7, 0xa9);
1470                         cirrusfb_set_mclk (cinfo, regs.mclk, regs.divMCLK);
1471                         break;
1472
1473                 case BT_GD5480:
1474                         DPRINTK (" (for GD5480)\n");
1475                         vga_wseq (regbase, CL_SEQR7, 0x19);
1476                         /* We already set SRF and SR1F */
1477                         break;
1478
1479                 case BT_LAGUNA:
1480                         DPRINTK (" (for GD546x)\n");
1481                         vga_wseq (regbase, CL_SEQR7,
1482                                 vga_rseq (regbase, CL_SEQR7) & ~0x01);
1483                         break;
1484
1485                 default:
1486                         printk (KERN_WARNING "cirrusfb: unknown Board\n");
1487                         break;
1488                 }
1489
1490                 vga_wgfx (regbase, VGA_GFX_MODE, 64);   /* mode register: 256 color mode */
1491                 WGen (cinfo, VGA_PEL_MSK, 0xff);        /* pixel mask: pass-through all planes */
1492                 WHDR (cinfo, 0xc5);     /* hidden dac reg: 8-8-8 mode (24 or 32) */
1493                 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x0a);  /* memory mode: chain4, ext. memory */
1494                 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0xff);  /* plane mask: enable writing to all 4 planes */
1495                 offset = var->xres_virtual / 4;
1496         }
1497
1498         /******************************************************
1499          *
1500          * unknown/unsupported bpp
1501          *
1502          */
1503
1504         else {
1505                 printk (KERN_ERR "cirrusfb: What's this?? requested color depth == %d.\n",
1506                         var->bits_per_pixel);
1507         }
1508
1509         vga_wcrt (regbase, VGA_CRTC_OFFSET, offset & 0xff);
1510         tmp = 0x22;
1511         if (offset & 0x100)
1512                 tmp |= 0x10;    /* offset overflow bit */
1513
1514         vga_wcrt (regbase, CL_CRT1B, tmp);      /* screen start addr #16-18, fastpagemode cycles */
1515
1516         if (cinfo->btype == BT_SD64 ||
1517             cinfo->btype == BT_PICASSO4 ||
1518             cinfo->btype == BT_ALPINE ||
1519             cinfo->btype == BT_GD5480)
1520                 vga_wcrt (regbase, CL_CRT1D, 0x00);     /* screen start address bit 19 */
1521
1522         vga_wcrt (regbase, VGA_CRTC_CURSOR_HI, 0);      /* text cursor location high */
1523         vga_wcrt (regbase, VGA_CRTC_CURSOR_LO, 0);      /* text cursor location low */
1524         vga_wcrt (regbase, VGA_CRTC_UNDERLINE, 0);      /* underline row scanline = at very bottom */
1525
1526         vga_wattr (regbase, VGA_ATC_MODE, 1);   /* controller mode */
1527         vga_wattr (regbase, VGA_ATC_OVERSCAN, 0);               /* overscan (border) color */
1528         vga_wattr (regbase, VGA_ATC_PLANE_ENABLE, 15);  /* color plane enable */
1529         vga_wattr (regbase, CL_AR33, 0);        /* pixel panning */
1530         vga_wattr (regbase, VGA_ATC_COLOR_PAGE, 0);     /* color select */
1531
1532         /* [ EGS: SetOffset(); ] */
1533         /* From SetOffset(): Turn on VideoEnable bit in Attribute controller */
1534         AttrOn (cinfo);
1535
1536         vga_wgfx (regbase, VGA_GFX_SR_VALUE, 0);        /* set/reset register */
1537         vga_wgfx (regbase, VGA_GFX_SR_ENABLE, 0);               /* set/reset enable */
1538         vga_wgfx (regbase, VGA_GFX_COMPARE_VALUE, 0);   /* color compare */
1539         vga_wgfx (regbase, VGA_GFX_DATA_ROTATE, 0);     /* data rotate */
1540         vga_wgfx (regbase, VGA_GFX_PLANE_READ, 0);      /* read map select */
1541         vga_wgfx (regbase, VGA_GFX_MISC, 1);    /* miscellaneous register */
1542         vga_wgfx (regbase, VGA_GFX_COMPARE_MASK, 15);   /* color don't care */
1543         vga_wgfx (regbase, VGA_GFX_BIT_MASK, 255);      /* bit mask */
1544
1545         vga_wseq (regbase, CL_SEQR12, 0x0);     /* graphics cursor attributes: nothing special */
1546
1547         /* finally, turn on everything - turn off "FullBandwidth" bit */
1548         /* also, set "DotClock%2" bit where requested */
1549         tmp = 0x01;
1550
1551 /*** FB_VMODE_CLOCK_HALVE in linux/fb.h not defined anymore ?
1552     if (var->vmode & FB_VMODE_CLOCK_HALVE)
1553         tmp |= 0x08;
1554 */
1555
1556         vga_wseq (regbase, VGA_SEQ_CLOCK_MODE, tmp);
1557         DPRINTK ("CL_SEQR1: %d\n", tmp);
1558
1559         cinfo->currentmode = regs;
1560         info->fix.type = regs.type;
1561         info->fix.visual = regs.visual;
1562         info->fix.line_length = regs.line_length;
1563
1564         /* pan to requested offset */
1565         cirrusfb_pan_display (var, info);
1566
1567 #ifdef CIRRUSFB_DEBUG
1568         cirrusfb_dump ();
1569 #endif
1570
1571         DPRINTK ("EXIT\n");
1572         return 0;
1573 }
1574
1575 /* for some reason incomprehensible to me, cirrusfb requires that you write
1576  * the registers twice for the settings to take..grr. -dte */
1577 static int cirrusfb_set_par (struct fb_info *info)
1578 {
1579         cirrusfb_set_par_foo (info);
1580         return cirrusfb_set_par_foo (info);
1581 }
1582
1583 static int cirrusfb_setcolreg (unsigned regno, unsigned red, unsigned green,
1584                                unsigned blue, unsigned transp,
1585                                struct fb_info *info)
1586 {
1587         struct cirrusfb_info *cinfo = info->par;
1588
1589         if (regno > 255)
1590                 return -EINVAL;
1591
1592         if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
1593                 u32 v;
1594                 red >>= (16 - info->var.red.length);
1595                 green >>= (16 - info->var.green.length);
1596                 blue >>= (16 - info->var.blue.length);
1597
1598                 if (regno>=16)
1599                         return 1;
1600                 v = (red << info->var.red.offset) |
1601                     (green << info->var.green.offset) |
1602                     (blue << info->var.blue.offset);
1603
1604                 switch (info->var.bits_per_pixel) {
1605                         case 8:
1606                                 cinfo->pseudo_palette[regno] = v;
1607                                 break;
1608                         case 16:
1609                                 cinfo->pseudo_palette[regno] = v;
1610                                 break;
1611                         case 24:
1612                         case 32:
1613                                 cinfo->pseudo_palette[regno] = v;
1614                                 break;
1615                 }
1616                 return 0;
1617         }
1618
1619         cinfo->palette[regno].red = red;
1620         cinfo->palette[regno].green = green;
1621         cinfo->palette[regno].blue = blue;
1622
1623         if (info->var.bits_per_pixel == 8) {
1624                         WClut (cinfo, regno, red >> 10, green >> 10, blue >> 10);
1625         }
1626
1627         return 0;
1628
1629 }
1630
1631 /*************************************************************************
1632         cirrusfb_pan_display()
1633
1634         performs display panning - provided hardware permits this
1635 **************************************************************************/
1636 static int cirrusfb_pan_display (struct fb_var_screeninfo *var,
1637                                  struct fb_info *info)
1638 {
1639         int xoffset = 0;
1640         int yoffset = 0;
1641         unsigned long base;
1642         unsigned char tmp = 0, tmp2 = 0, xpix;
1643         struct cirrusfb_info *cinfo = info->par;
1644
1645         DPRINTK ("ENTER\n");
1646         DPRINTK ("virtual offset: (%d,%d)\n", var->xoffset, var->yoffset);
1647
1648         /* no range checks for xoffset and yoffset,   */
1649         /* as fb_pan_display has already done this */
1650         if (var->vmode & FB_VMODE_YWRAP)
1651                 return -EINVAL;
1652
1653         info->var.xoffset = var->xoffset;
1654         info->var.yoffset = var->yoffset;
1655
1656         xoffset = var->xoffset * info->var.bits_per_pixel / 8;
1657         yoffset = var->yoffset;
1658
1659         base = yoffset * cinfo->currentmode.line_length + xoffset;
1660
1661         if (info->var.bits_per_pixel == 1) {
1662                 /* base is already correct */
1663                 xpix = (unsigned char) (var->xoffset % 8);
1664         } else {
1665                 base /= 4;
1666                 xpix = (unsigned char) ((xoffset % 4) * 2);
1667         }
1668
1669         cirrusfb_WaitBLT(cinfo->regbase); /* make sure all the BLT's are done */
1670
1671         /* lower 8 + 8 bits of screen start address */
1672         vga_wcrt (cinfo->regbase, VGA_CRTC_START_LO, (unsigned char) (base & 0xff));
1673         vga_wcrt (cinfo->regbase, VGA_CRTC_START_HI, (unsigned char) (base >> 8));
1674
1675         /* construct bits 16, 17 and 18 of screen start address */
1676         if (base & 0x10000)
1677                 tmp |= 0x01;
1678         if (base & 0x20000)
1679                 tmp |= 0x04;
1680         if (base & 0x40000)
1681                 tmp |= 0x08;
1682
1683         tmp2 = (vga_rcrt (cinfo->regbase, CL_CRT1B) & 0xf2) | tmp;      /* 0xf2 is %11110010, exclude tmp bits */
1684         vga_wcrt (cinfo->regbase, CL_CRT1B, tmp2);
1685
1686         /* construct bit 19 of screen start address */
1687         if (cirrusfb_board_info[cinfo->btype].scrn_start_bit19) {
1688                 tmp2 = 0;
1689                 if (base & 0x80000)
1690                         tmp2 = 0x80;
1691                 vga_wcrt (cinfo->regbase, CL_CRT1D, tmp2);
1692         }
1693
1694         /* write pixel panning value to AR33; this does not quite work in 8bpp */
1695         /* ### Piccolo..? Will this work? */
1696         if (info->var.bits_per_pixel == 1)
1697                 vga_wattr (cinfo->regbase, CL_AR33, xpix);
1698
1699         cirrusfb_WaitBLT (cinfo->regbase);
1700
1701         DPRINTK ("EXIT\n");
1702         return (0);
1703 }
1704
1705
1706 static int cirrusfb_blank (int blank_mode, struct fb_info *info)
1707 {
1708         /*
1709          *  Blank the screen if blank_mode != 0, else unblank. If blank == NULL
1710          *  then the caller blanks by setting the CLUT (Color Look Up Table) to all
1711          *  black. Return 0 if blanking succeeded, != 0 if un-/blanking failed due
1712          *  to e.g. a video mode which doesn't support it. Implements VESA suspend
1713          *  and powerdown modes on hardware that supports disabling hsync/vsync:
1714          *    blank_mode == 2: suspend vsync
1715          *    blank_mode == 3: suspend hsync
1716          *    blank_mode == 4: powerdown
1717          */
1718         unsigned char val;
1719         struct cirrusfb_info *cinfo = info->par;
1720         int current_mode = cinfo->blank_mode;
1721
1722         DPRINTK ("ENTER, blank mode = %d\n", blank_mode);
1723
1724         if (info->state != FBINFO_STATE_RUNNING ||
1725             current_mode == blank_mode) {
1726                 DPRINTK ("EXIT, returning 0\n");
1727                 return 0;
1728         }
1729
1730         /* Undo current */
1731         if (current_mode == FB_BLANK_NORMAL ||
1732             current_mode == FB_BLANK_UNBLANK) {
1733                 /* unblank the screen */
1734                 val = vga_rseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE);
1735                 vga_wseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE, val & 0xdf);      /* clear "FullBandwidth" bit */
1736                 /* and undo VESA suspend trickery */
1737                 vga_wgfx (cinfo->regbase, CL_GRE, 0x00);
1738         }
1739
1740         /* set new */
1741         if(blank_mode > FB_BLANK_NORMAL) {
1742                 /* blank the screen */
1743                 val = vga_rseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE);
1744                 vga_wseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE, val | 0x20);      /* set "FullBandwidth" bit */
1745         }
1746
1747         switch (blank_mode) {
1748         case FB_BLANK_UNBLANK:
1749         case FB_BLANK_NORMAL:
1750                 break;
1751         case FB_BLANK_VSYNC_SUSPEND:
1752                 vga_wgfx (cinfo->regbase, CL_GRE, 0x04);
1753                 break;
1754         case FB_BLANK_HSYNC_SUSPEND:
1755                 vga_wgfx (cinfo->regbase, CL_GRE, 0x02);
1756                 break;
1757         case FB_BLANK_POWERDOWN:
1758                 vga_wgfx (cinfo->regbase, CL_GRE, 0x06);
1759                 break;
1760         default:
1761                 DPRINTK ("EXIT, returning 1\n");
1762                 return 1;
1763         }
1764
1765         cinfo->blank_mode = blank_mode;
1766         DPRINTK ("EXIT, returning 0\n");
1767
1768         /* Let fbcon do a soft blank for us */
1769         return (blank_mode == FB_BLANK_NORMAL) ? 1 : 0;
1770 }
1771 /**** END   Hardware specific Routines **************************************/
1772 /****************************************************************************/
1773 /**** BEGIN Internal Routines ***********************************************/
1774
1775 static void init_vgachip (struct cirrusfb_info *cinfo)
1776 {
1777         const struct cirrusfb_board_info_rec *bi;
1778
1779         DPRINTK ("ENTER\n");
1780
1781         assert (cinfo != NULL);
1782
1783         bi = &cirrusfb_board_info[cinfo->btype];
1784
1785         /* reset board globally */
1786         switch (cinfo->btype) {
1787         case BT_PICCOLO:
1788                 WSFR (cinfo, 0x01);
1789                 udelay (500);
1790                 WSFR (cinfo, 0x51);
1791                 udelay (500);
1792                 break;
1793         case BT_PICASSO:
1794                 WSFR2 (cinfo, 0xff);
1795                 udelay (500);
1796                 break;
1797         case BT_SD64:
1798         case BT_SPECTRUM:
1799                 WSFR (cinfo, 0x1f);
1800                 udelay (500);
1801                 WSFR (cinfo, 0x4f);
1802                 udelay (500);
1803                 break;
1804         case BT_PICASSO4:
1805                 vga_wcrt (cinfo->regbase, CL_CRT51, 0x00);      /* disable flickerfixer */
1806                 mdelay (100);
1807                 vga_wgfx (cinfo->regbase, CL_GR2F, 0x00);       /* from Klaus' NetBSD driver: */
1808                 vga_wgfx (cinfo->regbase, CL_GR33, 0x00);       /* put blitter into 542x compat */
1809                 vga_wgfx (cinfo->regbase, CL_GR31, 0x00);       /* mode */
1810                 break;
1811
1812         case BT_GD5480:
1813                 vga_wgfx (cinfo->regbase, CL_GR2F, 0x00);       /* from Klaus' NetBSD driver: */
1814                 break;
1815
1816         case BT_ALPINE:
1817                 /* Nothing to do to reset the board. */
1818                 break;
1819
1820         default:
1821                 printk (KERN_ERR "cirrusfb: Warning: Unknown board type\n");
1822                 break;
1823         }
1824
1825         assert (cinfo->size > 0); /* make sure RAM size set by this point */
1826
1827         /* the P4 is not fully initialized here; I rely on it having been */
1828         /* inited under AmigaOS already, which seems to work just fine    */
1829         /* (Klaus advised to do it this way)                              */
1830
1831         if (cinfo->btype != BT_PICASSO4) {
1832                 WGen (cinfo, CL_VSSM, 0x10);    /* EGS: 0x16 */
1833                 WGen (cinfo, CL_POS102, 0x01);
1834                 WGen (cinfo, CL_VSSM, 0x08);    /* EGS: 0x0e */
1835
1836                 if (cinfo->btype != BT_SD64)
1837                         WGen (cinfo, CL_VSSM2, 0x01);
1838
1839                 vga_wseq (cinfo->regbase, CL_SEQR0, 0x03);      /* reset sequencer logic */
1840
1841                 vga_wseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE, 0x21);    /* FullBandwidth (video off) and 8/9 dot clock */
1842                 WGen (cinfo, VGA_MIS_W, 0xc1);  /* polarity (-/-), disable access to display memory, VGA_CRTC_START_HI base address: color */
1843
1844 /*      vga_wgfx (cinfo->regbase, CL_GRA, 0xce);    "magic cookie" - doesn't make any sense to me.. */
1845                 vga_wseq (cinfo->regbase, CL_SEQR6, 0x12);      /* unlock all extension registers */
1846
1847                 vga_wgfx (cinfo->regbase, CL_GR31, 0x04);       /* reset blitter */
1848
1849                 switch (cinfo->btype) {
1850                 case BT_GD5480:
1851                         vga_wseq (cinfo->regbase, CL_SEQRF, 0x98);
1852                         break;
1853                 case BT_ALPINE:
1854                         break;
1855                 case BT_SD64:
1856                         vga_wseq (cinfo->regbase, CL_SEQRF, 0xb8);
1857                         break;
1858                 default:
1859                         vga_wseq (cinfo->regbase, CL_SEQR16, 0x0f);
1860                         vga_wseq (cinfo->regbase, CL_SEQRF, 0xb0);
1861                         break;
1862                 }
1863         }
1864         vga_wseq (cinfo->regbase, VGA_SEQ_PLANE_WRITE, 0xff);   /* plane mask: nothing */
1865         vga_wseq (cinfo->regbase, VGA_SEQ_CHARACTER_MAP, 0x00); /* character map select: doesn't even matter in gx mode */
1866         vga_wseq (cinfo->regbase, VGA_SEQ_MEMORY_MODE, 0x0e);   /* memory mode: chain-4, no odd/even, ext. memory */
1867
1868         /* controller-internal base address of video memory */
1869         if (bi->init_sr07)
1870                 vga_wseq (cinfo->regbase, CL_SEQR7, bi->sr07);
1871
1872         /*  vga_wseq (cinfo->regbase, CL_SEQR8, 0x00); *//* EEPROM control: shouldn't be necessary to write to this at all.. */
1873
1874         vga_wseq (cinfo->regbase, CL_SEQR10, 0x00);             /* graphics cursor X position (incomplete; position gives rem. 3 bits */
1875         vga_wseq (cinfo->regbase, CL_SEQR11, 0x00);             /* graphics cursor Y position (..."... ) */
1876         vga_wseq (cinfo->regbase, CL_SEQR12, 0x00);             /* graphics cursor attributes */
1877         vga_wseq (cinfo->regbase, CL_SEQR13, 0x00);             /* graphics cursor pattern address */
1878
1879         /* writing these on a P4 might give problems..  */
1880         if (cinfo->btype != BT_PICASSO4) {
1881                 vga_wseq (cinfo->regbase, CL_SEQR17, 0x00);             /* configuration readback and ext. color */
1882                 vga_wseq (cinfo->regbase, CL_SEQR18, 0x02);             /* signature generator */
1883         }
1884
1885         /* MCLK select etc. */
1886         if (bi->init_sr1f)
1887                 vga_wseq (cinfo->regbase, CL_SEQR1F, bi->sr1f);
1888
1889         vga_wcrt (cinfo->regbase, VGA_CRTC_PRESET_ROW, 0x00);   /* Screen A preset row scan: none */
1890         vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_START, 0x20); /* Text cursor start: disable text cursor */
1891         vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_END, 0x00);   /* Text cursor end: - */
1892         vga_wcrt (cinfo->regbase, VGA_CRTC_START_HI, 0x00);     /* Screen start address high: 0 */
1893         vga_wcrt (cinfo->regbase, VGA_CRTC_START_LO, 0x00);     /* Screen start address low: 0 */
1894         vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_HI, 0x00);    /* text cursor location high: 0 */
1895         vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_LO, 0x00);    /* text cursor location low: 0 */
1896
1897         vga_wcrt (cinfo->regbase, VGA_CRTC_UNDERLINE, 0x00);    /* Underline Row scanline: - */
1898         vga_wcrt (cinfo->regbase, VGA_CRTC_MODE, 0xc3); /* mode control: timing enable, byte mode, no compat modes */
1899         vga_wcrt (cinfo->regbase, VGA_CRTC_LINE_COMPARE, 0x00); /* Line Compare: not needed */
1900         /* ### add 0x40 for text modes with > 30 MHz pixclock */
1901         vga_wcrt (cinfo->regbase, CL_CRT1B, 0x02);      /* ext. display controls: ext.adr. wrap */
1902
1903         vga_wgfx (cinfo->regbase, VGA_GFX_SR_VALUE, 0x00);      /* Set/Reset registes: - */
1904         vga_wgfx (cinfo->regbase, VGA_GFX_SR_ENABLE, 0x00);     /* Set/Reset enable: - */
1905         vga_wgfx (cinfo->regbase, VGA_GFX_COMPARE_VALUE, 0x00); /* Color Compare: - */
1906         vga_wgfx (cinfo->regbase, VGA_GFX_DATA_ROTATE, 0x00);   /* Data Rotate: - */
1907         vga_wgfx (cinfo->regbase, VGA_GFX_PLANE_READ, 0x00);    /* Read Map Select: - */
1908         vga_wgfx (cinfo->regbase, VGA_GFX_MODE, 0x00);  /* Mode: conf. for 16/4/2 color mode, no odd/even, read/write mode 0 */
1909         vga_wgfx (cinfo->regbase, VGA_GFX_MISC, 0x01);  /* Miscellaneous: memory map base address, graphics mode */
1910         vga_wgfx (cinfo->regbase, VGA_GFX_COMPARE_MASK, 0x0f);  /* Color Don't care: involve all planes */
1911         vga_wgfx (cinfo->regbase, VGA_GFX_BIT_MASK, 0xff);      /* Bit Mask: no mask at all */
1912         if (cinfo->btype == BT_ALPINE)
1913                 vga_wgfx (cinfo->regbase, CL_GRB, 0x20);        /* (5434 can't have bit 3 set for bitblt) */
1914         else
1915                 vga_wgfx (cinfo->regbase, CL_GRB, 0x28);        /* Graphics controller mode extensions: finer granularity, 8byte data latches */
1916
1917         vga_wgfx (cinfo->regbase, CL_GRC, 0xff);        /* Color Key compare: - */
1918         vga_wgfx (cinfo->regbase, CL_GRD, 0x00);        /* Color Key compare mask: - */
1919         vga_wgfx (cinfo->regbase, CL_GRE, 0x00);        /* Miscellaneous control: - */
1920         /*  vga_wgfx (cinfo->regbase, CL_GR10, 0x00); *//* Background color byte 1: - */
1921 /*  vga_wgfx (cinfo->regbase, CL_GR11, 0x00); */
1922
1923         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE0, 0x00);     /* Attribute Controller palette registers: "identity mapping" */
1924         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE1, 0x01);
1925         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE2, 0x02);
1926         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE3, 0x03);
1927         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE4, 0x04);
1928         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE5, 0x05);
1929         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE6, 0x06);
1930         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE7, 0x07);
1931         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE8, 0x08);
1932         vga_wattr (cinfo->regbase, VGA_ATC_PALETTE9, 0x09);
1933         vga_wattr (cinfo->regbase, VGA_ATC_PALETTEA, 0x0a);
1934         vga_wattr (cinfo->regbase, VGA_ATC_PALETTEB, 0x0b);
1935         vga_wattr (cinfo->regbase, VGA_ATC_PALETTEC, 0x0c);
1936         vga_wattr (cinfo->regbase, VGA_ATC_PALETTED, 0x0d);
1937         vga_wattr (cinfo->regbase, VGA_ATC_PALETTEE, 0x0e);
1938         vga_wattr (cinfo->regbase, VGA_ATC_PALETTEF, 0x0f);
1939
1940         vga_wattr (cinfo->regbase, VGA_ATC_MODE, 0x01); /* Attribute Controller mode: graphics mode */
1941         vga_wattr (cinfo->regbase, VGA_ATC_OVERSCAN, 0x00);     /* Overscan color reg.: reg. 0 */
1942         vga_wattr (cinfo->regbase, VGA_ATC_PLANE_ENABLE, 0x0f); /* Color Plane enable: Enable all 4 planes */
1943 /* ###  vga_wattr (cinfo->regbase, CL_AR33, 0x00); * Pixel Panning: - */
1944         vga_wattr (cinfo->regbase, VGA_ATC_COLOR_PAGE, 0x00);   /* Color Select: - */
1945
1946         WGen (cinfo, VGA_PEL_MSK, 0xff);        /* Pixel mask: no mask */
1947
1948         if (cinfo->btype != BT_ALPINE && cinfo->btype != BT_GD5480)
1949                 WGen (cinfo, VGA_MIS_W, 0xc3);  /* polarity (-/-), enable display mem, VGA_CRTC_START_HI i/o base = color */
1950
1951         vga_wgfx (cinfo->regbase, CL_GR31, 0x04);       /* BLT Start/status: Blitter reset */
1952         vga_wgfx (cinfo->regbase, CL_GR31, 0x00);       /* - " -           : "end-of-reset" */
1953
1954         /* misc... */
1955         WHDR (cinfo, 0);        /* Hidden DAC register: - */
1956
1957         printk (KERN_DEBUG "cirrusfb: This board has %ld bytes of DRAM memory\n", cinfo->size);
1958         DPRINTK ("EXIT\n");
1959         return;
1960 }
1961
1962 static void switch_monitor (struct cirrusfb_info *cinfo, int on)
1963 {
1964 #ifdef CONFIG_ZORRO /* only works on Zorro boards */
1965         static int IsOn = 0;    /* XXX not ok for multiple boards */
1966
1967         DPRINTK ("ENTER\n");
1968
1969         if (cinfo->btype == BT_PICASSO4)
1970                 return;         /* nothing to switch */
1971         if (cinfo->btype == BT_ALPINE)
1972                 return;         /* nothing to switch */
1973         if (cinfo->btype == BT_GD5480)
1974                 return;         /* nothing to switch */
1975         if (cinfo->btype == BT_PICASSO) {
1976                 if ((on && !IsOn) || (!on && IsOn))
1977                         WSFR (cinfo, 0xff);
1978
1979                 DPRINTK ("EXIT\n");
1980                 return;
1981         }
1982         if (on) {
1983                 switch (cinfo->btype) {
1984                 case BT_SD64:
1985                         WSFR (cinfo, cinfo->SFR | 0x21);
1986                         break;
1987                 case BT_PICCOLO:
1988                         WSFR (cinfo, cinfo->SFR | 0x28);
1989                         break;
1990                 case BT_SPECTRUM:
1991                         WSFR (cinfo, 0x6f);
1992                         break;
1993                 default: /* do nothing */ break;
1994                 }
1995         } else {
1996                 switch (cinfo->btype) {
1997                 case BT_SD64:
1998                         WSFR (cinfo, cinfo->SFR & 0xde);
1999                         break;
2000                 case BT_PICCOLO:
2001                         WSFR (cinfo, cinfo->SFR & 0xd7);
2002                         break;
2003                 case BT_SPECTRUM:
2004                         WSFR (cinfo, 0x4f);
2005                         break;
2006                 default: /* do nothing */ break;
2007                 }
2008         }
2009
2010         DPRINTK ("EXIT\n");
2011 #endif /* CONFIG_ZORRO */
2012 }
2013
2014
2015 /******************************************/
2016 /* Linux 2.6-style  accelerated functions */
2017 /******************************************/
2018
2019 static void cirrusfb_prim_fillrect(struct cirrusfb_info *cinfo,
2020                                    const struct fb_fillrect *region)
2021 {
2022         int m; /* bytes per pixel */
2023         u32 color = (cinfo->info->fix.visual == FB_VISUAL_TRUECOLOR) ?
2024                 cinfo->pseudo_palette[region->color] : region->color;
2025
2026         if(cinfo->info->var.bits_per_pixel == 1) {
2027                 cirrusfb_RectFill(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2028                                   region->dx / 8, region->dy,
2029                                   region->width / 8, region->height,
2030                                   color,
2031                                   cinfo->currentmode.line_length);
2032         } else {
2033                 m = ( cinfo->info->var.bits_per_pixel + 7 ) / 8;
2034                 cirrusfb_RectFill(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2035                                   region->dx * m, region->dy,
2036                                   region->width * m, region->height,
2037                                   color,
2038                                   cinfo->currentmode.line_length);
2039         }
2040         return;
2041 }
2042
2043 static void cirrusfb_fillrect (struct fb_info *info, const struct fb_fillrect *region)
2044 {
2045         struct cirrusfb_info *cinfo = info->par;
2046         struct fb_fillrect modded;
2047         int vxres, vyres;
2048
2049         if (info->state != FBINFO_STATE_RUNNING)
2050                 return;
2051         if (info->flags & FBINFO_HWACCEL_DISABLED) {
2052                 cfb_fillrect(info, region);
2053                 return;
2054         }
2055
2056         vxres = info->var.xres_virtual;
2057         vyres = info->var.yres_virtual;
2058
2059         memcpy(&modded, region, sizeof(struct fb_fillrect));
2060
2061         if(!modded.width || !modded.height ||
2062            modded.dx >= vxres || modded.dy >= vyres)
2063                 return;
2064
2065         if(modded.dx + modded.width  > vxres) modded.width  = vxres - modded.dx;
2066         if(modded.dy + modded.height > vyres) modded.height = vyres - modded.dy;
2067
2068         cirrusfb_prim_fillrect(cinfo, &modded);
2069 }
2070
2071 static void cirrusfb_prim_copyarea(struct cirrusfb_info *cinfo,
2072                                    const struct fb_copyarea *area)
2073 {
2074         int m; /* bytes per pixel */
2075         if(cinfo->info->var.bits_per_pixel == 1) {
2076                 cirrusfb_BitBLT(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2077                                 area->sx / 8, area->sy,
2078                                 area->dx / 8, area->dy,
2079                                 area->width / 8, area->height,
2080                                 cinfo->currentmode.line_length);
2081         } else {
2082                 m = ( cinfo->info->var.bits_per_pixel + 7 ) / 8;
2083                 cirrusfb_BitBLT(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2084                                 area->sx * m, area->sy,
2085                                 area->dx * m, area->dy,
2086                                 area->width * m, area->height,
2087                                 cinfo->currentmode.line_length);
2088         }
2089         return;
2090 }
2091
2092
2093 static void cirrusfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
2094 {
2095         struct cirrusfb_info *cinfo = info->par;
2096         struct fb_copyarea modded;
2097         u32 vxres, vyres;
2098         modded.sx = area->sx;
2099         modded.sy = area->sy;
2100         modded.dx = area->dx;
2101         modded.dy = area->dy;
2102         modded.width  = area->width;
2103         modded.height = area->height;
2104
2105         if (info->state != FBINFO_STATE_RUNNING)
2106                 return;
2107         if (info->flags & FBINFO_HWACCEL_DISABLED) {
2108                 cfb_copyarea(info, area);
2109                 return;
2110         }
2111
2112         vxres = info->var.xres_virtual;
2113         vyres = info->var.yres_virtual;
2114
2115         if(!modded.width || !modded.height ||
2116            modded.sx >= vxres || modded.sy >= vyres ||
2117            modded.dx >= vxres || modded.dy >= vyres)
2118                 return;
2119
2120         if(modded.sx + modded.width > vxres)  modded.width = vxres - modded.sx;
2121         if(modded.dx + modded.width > vxres)  modded.width = vxres - modded.dx;
2122         if(modded.sy + modded.height > vyres) modded.height = vyres - modded.sy;
2123         if(modded.dy + modded.height > vyres) modded.height = vyres - modded.dy;
2124
2125         cirrusfb_prim_copyarea(cinfo, &modded);
2126 }
2127
2128 static void cirrusfb_imageblit(struct fb_info *info, const struct fb_image *image)
2129 {
2130         struct cirrusfb_info *cinfo = info->par;
2131
2132         cirrusfb_WaitBLT(cinfo->regbase);
2133         cfb_imageblit(info, image);
2134 }
2135
2136
2137 #ifdef CONFIG_PPC_PREP
2138 #define PREP_VIDEO_BASE ((volatile unsigned long) 0xC0000000)
2139 #define PREP_IO_BASE    ((volatile unsigned char *) 0x80000000)
2140 static void get_prep_addrs (unsigned long *display, unsigned long *registers)
2141 {
2142         DPRINTK ("ENTER\n");
2143
2144         *display = PREP_VIDEO_BASE;
2145         *registers = (unsigned long) PREP_IO_BASE;
2146
2147         DPRINTK ("EXIT\n");
2148 }
2149
2150 #endif                          /* CONFIG_PPC_PREP */
2151
2152
2153 #ifdef CONFIG_PCI
2154 static int release_io_ports = 0;
2155
2156 /* Pulled the logic from XFree86 Cirrus driver to get the memory size,
2157  * based on the DRAM bandwidth bit and DRAM bank switching bit.  This
2158  * works with 1MB, 2MB and 4MB configurations (which the Motorola boards
2159  * seem to have. */
2160 static unsigned int cirrusfb_get_memsize (u8 __iomem *regbase)
2161 {
2162         unsigned long mem;
2163         unsigned char SRF;
2164
2165         DPRINTK ("ENTER\n");
2166
2167         SRF = vga_rseq (regbase, CL_SEQRF);
2168         switch ((SRF & 0x18)) {
2169             case 0x08: mem = 512 * 1024; break;
2170             case 0x10: mem = 1024 * 1024; break;
2171                 /* 64-bit DRAM data bus width; assume 2MB. Also indicates 2MB memory
2172                    * on the 5430. */
2173             case 0x18: mem = 2048 * 1024; break;
2174             default: printk ("CLgenfb: Unknown memory size!\n");
2175                 mem = 1024 * 1024;
2176         }
2177         if (SRF & 0x80) {
2178                 /* If DRAM bank switching is enabled, there must be twice as much
2179                    * memory installed. (4MB on the 5434) */
2180                 mem *= 2;
2181         }
2182         /* TODO: Handling of GD5446/5480 (see XF86 sources ...) */
2183
2184         DPRINTK ("EXIT\n");
2185         return mem;
2186 }
2187
2188
2189
2190 static void get_pci_addrs (const struct pci_dev *pdev,
2191                            unsigned long *display, unsigned long *registers)
2192 {
2193         assert (pdev != NULL);
2194         assert (display != NULL);
2195         assert (registers != NULL);
2196
2197         DPRINTK ("ENTER\n");
2198
2199         *display = 0;
2200         *registers = 0;
2201
2202         /* This is a best-guess for now */
2203
2204         if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2205                 *display = pci_resource_start(pdev, 1);
2206                 *registers = pci_resource_start(pdev, 0);
2207         } else {
2208                 *display = pci_resource_start(pdev, 0);
2209                 *registers = pci_resource_start(pdev, 1);
2210         }
2211
2212         assert (*display != 0);
2213
2214         DPRINTK ("EXIT\n");
2215 }
2216
2217
2218 static void cirrusfb_pci_unmap (struct cirrusfb_info *cinfo)
2219 {
2220         struct pci_dev *pdev = cinfo->pdev;
2221
2222         iounmap(cinfo->fbmem);
2223 #if 0 /* if system didn't claim this region, we would... */
2224         release_mem_region(0xA0000, 65535);
2225 #endif
2226         if (release_io_ports)
2227                 release_region(0x3C0, 32);
2228         pci_release_regions(pdev);
2229         framebuffer_release(cinfo->info);
2230         pci_disable_device(pdev);
2231 }
2232 #endif /* CONFIG_PCI */
2233
2234
2235 #ifdef CONFIG_ZORRO
2236 static void __devexit cirrusfb_zorro_unmap (struct cirrusfb_info *cinfo)
2237 {
2238         zorro_release_device(cinfo->zdev);
2239
2240         if (cinfo->btype == BT_PICASSO4) {
2241                 cinfo->regbase -= 0x600000;
2242                 iounmap ((void *)cinfo->regbase);
2243                 iounmap ((void *)cinfo->fbmem);
2244         } else {
2245                 if (zorro_resource_start(cinfo->zdev) > 0x01000000)
2246                         iounmap ((void *)cinfo->fbmem);
2247         }
2248         framebuffer_release(cinfo->info);
2249 }
2250 #endif /* CONFIG_ZORRO */
2251
2252 static int cirrusfb_set_fbinfo(struct cirrusfb_info *cinfo)
2253 {
2254         struct fb_info *info = cinfo->info;
2255         struct fb_var_screeninfo *var = &info->var;
2256
2257         info->par = cinfo;
2258         info->pseudo_palette = cinfo->pseudo_palette;
2259         info->flags = FBINFO_DEFAULT
2260                     | FBINFO_HWACCEL_XPAN
2261                     | FBINFO_HWACCEL_YPAN
2262                     | FBINFO_HWACCEL_FILLRECT
2263                     | FBINFO_HWACCEL_COPYAREA;
2264         if (noaccel)
2265                 info->flags |= FBINFO_HWACCEL_DISABLED;
2266         info->fbops = &cirrusfb_ops;
2267         info->screen_base = cinfo->fbmem;
2268         if (cinfo->btype == BT_GD5480) {
2269                 if (var->bits_per_pixel == 16)
2270                         info->screen_base += 1 * MB_;
2271                 if (var->bits_per_pixel == 24 || var->bits_per_pixel == 32)
2272                         info->screen_base += 2 * MB_;
2273         }
2274
2275         /* Fill fix common fields */
2276         strlcpy(info->fix.id, cirrusfb_board_info[cinfo->btype].name,
2277                 sizeof(info->fix.id));
2278
2279         /* monochrome: only 1 memory plane */
2280         /* 8 bit and above: Use whole memory area */
2281         info->fix.smem_start = cinfo->fbmem_phys;
2282         info->fix.smem_len   = (var->bits_per_pixel == 1) ? cinfo->size / 4 : cinfo->size;
2283         info->fix.type       = cinfo->currentmode.type;
2284         info->fix.type_aux   = 0;
2285         info->fix.visual     = cinfo->currentmode.visual;
2286         info->fix.xpanstep   = 1;
2287         info->fix.ypanstep   = 1;
2288         info->fix.ywrapstep  = 0;
2289         info->fix.line_length = cinfo->currentmode.line_length;
2290
2291         /* FIXME: map region at 0xB8000 if available, fill in here */
2292         info->fix.mmio_start = cinfo->fbregs_phys;
2293         info->fix.mmio_len   = 0;
2294         info->fix.accel = FB_ACCEL_NONE;
2295
2296         fb_alloc_cmap(&info->cmap, 256, 0);
2297
2298         return 0;
2299 }
2300
2301 static int cirrusfb_register(struct cirrusfb_info *cinfo)
2302 {
2303         struct fb_info *info;
2304         int err;
2305         cirrusfb_board_t btype;
2306
2307         DPRINTK ("ENTER\n");
2308
2309         printk (KERN_INFO "cirrusfb: Driver for Cirrus Logic based graphic boards, v" CIRRUSFB_VERSION "\n");
2310
2311         info = cinfo->info;
2312         btype = cinfo->btype;
2313
2314         /* sanity checks */
2315         assert (btype != BT_NONE);
2316
2317         DPRINTK ("cirrusfb: (RAM start set to: 0x%p)\n", cinfo->fbmem);
2318
2319         /* Make pretend we've set the var so our structures are in a "good" */
2320         /* state, even though we haven't written the mode to the hw yet...  */
2321         info->var = cirrusfb_predefined[cirrusfb_def_mode].var;
2322         info->var.activate = FB_ACTIVATE_NOW;
2323
2324         err = cirrusfb_decode_var(&info->var, &cinfo->currentmode, info);
2325         if (err < 0) {
2326                 /* should never happen */
2327                 DPRINTK("choking on default var... umm, no good.\n");
2328                 goto err_unmap_cirrusfb;
2329         }
2330
2331         /* set all the vital stuff */
2332         cirrusfb_set_fbinfo(cinfo);
2333
2334         err = register_framebuffer(info);
2335         if (err < 0) {
2336                 printk (KERN_ERR "cirrusfb: could not register fb device; err = %d!\n", err);
2337                 goto err_dealloc_cmap;
2338         }
2339
2340         DPRINTK ("EXIT, returning 0\n");
2341         return 0;
2342
2343 err_dealloc_cmap:
2344         fb_dealloc_cmap(&info->cmap);
2345 err_unmap_cirrusfb:
2346         cinfo->unmap(cinfo);
2347         return err;
2348 }
2349
2350 static void __devexit cirrusfb_cleanup (struct fb_info *info)
2351 {
2352         struct cirrusfb_info *cinfo = info->par;
2353         DPRINTK ("ENTER\n");
2354
2355         switch_monitor (cinfo, 0);
2356
2357         unregister_framebuffer (info);
2358         fb_dealloc_cmap (&info->cmap);
2359         printk ("Framebuffer unregistered\n");
2360         cinfo->unmap(cinfo);
2361
2362         DPRINTK ("EXIT\n");
2363 }
2364
2365
2366 #ifdef CONFIG_PCI
2367 static int cirrusfb_pci_register (struct pci_dev *pdev,
2368                                   const struct pci_device_id *ent)
2369 {
2370         struct cirrusfb_info *cinfo;
2371         struct fb_info *info;
2372         cirrusfb_board_t btype;
2373         unsigned long board_addr, board_size;
2374         int ret;
2375
2376         ret = pci_enable_device(pdev);
2377         if (ret < 0) {
2378                 printk(KERN_ERR "cirrusfb: Cannot enable PCI device\n");
2379                 goto err_out;
2380         }
2381
2382         info = framebuffer_alloc(sizeof(struct cirrusfb_info), &pdev->dev);
2383         if (!info) {
2384                 printk(KERN_ERR "cirrusfb: could not allocate memory\n");
2385                 ret = -ENOMEM;
2386                 goto err_disable;
2387         }
2388
2389         cinfo = info->par;
2390         cinfo->info = info;
2391         cinfo->pdev = pdev;
2392         cinfo->btype = btype = (cirrusfb_board_t) ent->driver_data;
2393
2394         DPRINTK (" Found PCI device, base address 0 is 0x%lx, btype set to %d\n",
2395                 pdev->resource[0].start, btype);
2396         DPRINTK (" base address 1 is 0x%lx\n", pdev->resource[1].start);
2397
2398         if(isPReP) {
2399                 pci_write_config_dword (pdev, PCI_BASE_ADDRESS_0, 0x00000000);
2400 #ifdef CONFIG_PPC_PREP
2401                 get_prep_addrs (&board_addr, &cinfo->fbregs_phys);
2402 #endif
2403                 /* PReP dies if we ioremap the IO registers, but it works w/out... */
2404                 cinfo->regbase = (char __iomem *) cinfo->fbregs_phys;
2405         } else {
2406                 DPRINTK ("Attempt to get PCI info for Cirrus Graphics Card\n");
2407                 get_pci_addrs (pdev, &board_addr, &cinfo->fbregs_phys);
2408                 cinfo->regbase = NULL;          /* FIXME: this forces VGA.  alternatives? */
2409         }
2410
2411         DPRINTK ("Board address: 0x%lx, register address: 0x%lx\n", board_addr, cinfo->fbregs_phys);
2412
2413         board_size = (btype == BT_GD5480) ?
2414                 32 * MB_ : cirrusfb_get_memsize (cinfo->regbase);
2415
2416         ret = pci_request_regions(pdev, "cirrusfb");
2417         if (ret <0) {
2418                 printk(KERN_ERR "cirrusfb: cannot reserve region 0x%lx, abort\n",
2419                        board_addr);
2420                 goto err_release_fb;
2421         }
2422 #if 0 /* if the system didn't claim this region, we would... */
2423         if (!request_mem_region(0xA0000, 65535, "cirrusfb")) {
2424                 printk(KERN_ERR "cirrusfb: cannot reserve region 0x%lx, abort\n"
2425 ,
2426                        0xA0000L);
2427                 ret = -EBUSY;
2428                 goto err_release_regions;
2429         }
2430 #endif
2431         if (request_region(0x3C0, 32, "cirrusfb"))
2432                 release_io_ports = 1;
2433
2434         cinfo->fbmem = ioremap(board_addr, board_size);
2435         if (!cinfo->fbmem) {
2436                 ret = -EIO;
2437                 goto err_release_legacy;
2438         }
2439
2440         cinfo->fbmem_phys = board_addr;
2441         cinfo->size = board_size;
2442         cinfo->unmap = cirrusfb_pci_unmap;
2443
2444         printk (" RAM (%lu kB) at 0xx%lx, ", cinfo->size / KB_, board_addr);
2445         printk ("Cirrus Logic chipset on PCI bus\n");
2446         pci_set_drvdata(pdev, info);
2447
2448         return cirrusfb_register(cinfo);
2449
2450 err_release_legacy:
2451         if (release_io_ports)
2452                 release_region(0x3C0, 32);
2453 #if 0
2454         release_mem_region(0xA0000, 65535);
2455 err_release_regions:
2456 #endif
2457         pci_release_regions(pdev);
2458 err_release_fb:
2459         framebuffer_release(info);
2460 err_disable:
2461         pci_disable_device(pdev);
2462 err_out:
2463         return ret;
2464 }
2465
2466 static void __devexit cirrusfb_pci_unregister (struct pci_dev *pdev)
2467 {
2468         struct fb_info *info = pci_get_drvdata(pdev);
2469         DPRINTK ("ENTER\n");
2470
2471         cirrusfb_cleanup (info);
2472
2473         DPRINTK ("EXIT\n");
2474 }
2475
2476 static struct pci_driver cirrusfb_pci_driver = {
2477         .name           = "cirrusfb",
2478         .id_table       = cirrusfb_pci_table,
2479         .probe          = cirrusfb_pci_register,
2480         .remove         = __devexit_p(cirrusfb_pci_unregister),
2481 #ifdef CONFIG_PM
2482 #if 0
2483         .suspend        = cirrusfb_pci_suspend,
2484         .resume         = cirrusfb_pci_resume,
2485 #endif
2486 #endif
2487 };
2488 #endif /* CONFIG_PCI */
2489
2490
2491 #ifdef CONFIG_ZORRO
2492 static int cirrusfb_zorro_register(struct zorro_dev *z,
2493                                    const struct zorro_device_id *ent)
2494 {
2495         struct cirrusfb_info *cinfo;
2496         struct fb_info *info;
2497         cirrusfb_board_t btype;
2498         struct zorro_dev *z2 = NULL;
2499         unsigned long board_addr, board_size, size;
2500         int ret;
2501
2502         btype = ent->driver_data;
2503         if (cirrusfb_zorro_table2[btype].id2)
2504                 z2 = zorro_find_device(cirrusfb_zorro_table2[btype].id2, NULL);
2505         size = cirrusfb_zorro_table2[btype].size;
2506         printk(KERN_INFO "cirrusfb: %s board detected; ",
2507                cirrusfb_board_info[btype].name);
2508
2509         info = framebuffer_alloc(sizeof(struct cirrusfb_info), &z->dev);
2510         if (!info) {
2511                 printk (KERN_ERR "cirrusfb: could not allocate memory\n");
2512                 ret = -ENOMEM;
2513                 goto err_out;
2514         }
2515
2516         cinfo = info->par;
2517         cinfo->info = info;
2518         cinfo->btype = btype;
2519
2520         assert (z > 0);
2521         assert (z2 >= 0);
2522         assert (btype != BT_NONE);
2523
2524         cinfo->zdev = z;
2525         board_addr = zorro_resource_start(z);
2526         board_size = zorro_resource_len(z);
2527         cinfo->size = size;
2528
2529         if (!zorro_request_device(z, "cirrusfb")) {
2530                 printk(KERN_ERR "cirrusfb: cannot reserve region 0x%lx, abort\n",
2531                        board_addr);
2532                 ret = -EBUSY;
2533                 goto err_release_fb;
2534         }
2535
2536         printk (" RAM (%lu MB) at $%lx, ", board_size / MB_, board_addr);
2537
2538         ret = -EIO;
2539
2540         if (btype == BT_PICASSO4) {
2541                 printk (" REG at $%lx\n", board_addr + 0x600000);
2542
2543                 /* To be precise, for the P4 this is not the */
2544                 /* begin of the board, but the begin of RAM. */
2545                 /* for P4, map in its address space in 2 chunks (### TEST! ) */
2546                 /* (note the ugly hardcoded 16M number) */
2547                 cinfo->regbase = ioremap (board_addr, 16777216);
2548                 if (!cinfo->regbase)
2549                         goto err_release_region;
2550
2551                 DPRINTK ("cirrusfb: Virtual address for board set to: $%p\n", cinfo->regbase);
2552                 cinfo->regbase += 0x600000;
2553                 cinfo->fbregs_phys = board_addr + 0x600000;
2554
2555                 cinfo->fbmem_phys = board_addr + 16777216;
2556                 cinfo->fbmem = ioremap (cinfo->fbmem_phys, 16777216);
2557                 if (!cinfo->fbmem)
2558                         goto err_unmap_regbase;
2559         } else {
2560                 printk (" REG at $%lx\n", (unsigned long) z2->resource.start);
2561
2562                 cinfo->fbmem_phys = board_addr;
2563                 if (board_addr > 0x01000000)
2564                         cinfo->fbmem = ioremap (board_addr, board_size);
2565                 else
2566                         cinfo->fbmem = (caddr_t) ZTWO_VADDR (board_addr);
2567                 if (!cinfo->fbmem)
2568                         goto err_release_region;
2569
2570                 /* set address for REG area of board */
2571                 cinfo->regbase = (caddr_t) ZTWO_VADDR (z2->resource.start);
2572                 cinfo->fbregs_phys = z2->resource.start;
2573
2574                 DPRINTK ("cirrusfb: Virtual address for board set to: $%p\n", cinfo->regbase);
2575         }
2576         cinfo->unmap = cirrusfb_zorro_unmap;
2577
2578         printk (KERN_INFO "Cirrus Logic chipset on Zorro bus\n");
2579         zorro_set_drvdata(z, info);
2580
2581         return cirrusfb_register(cinfo);
2582
2583 err_unmap_regbase:
2584         /* Parental advisory: explicit hack */
2585         iounmap(cinfo->regbase - 0x600000);
2586 err_release_region:
2587         release_region(board_addr, board_size);
2588 err_release_fb:
2589         framebuffer_release(info);
2590 err_out:
2591         return ret;
2592 }
2593
2594 void __devexit cirrusfb_zorro_unregister(struct zorro_dev *z)
2595 {
2596         struct fb_info *info = zorro_get_drvdata(z);
2597         DPRINTK ("ENTER\n");
2598
2599         cirrusfb_cleanup (info);
2600
2601         DPRINTK ("EXIT\n");
2602 }
2603
2604 static struct zorro_driver cirrusfb_zorro_driver = {
2605         .name           = "cirrusfb",
2606         .id_table       = cirrusfb_zorro_table,
2607         .probe          = cirrusfb_zorro_register,
2608         .remove         = __devexit_p(cirrusfb_zorro_unregister),
2609 };
2610 #endif /* CONFIG_ZORRO */
2611
2612 static int __init cirrusfb_init(void)
2613 {
2614         int error = 0;
2615
2616 #ifndef MODULE
2617         char *option = NULL;
2618
2619         if (fb_get_options("cirrusfb", &option))
2620                 return -ENODEV;
2621         cirrusfb_setup(option);
2622 #endif
2623
2624 #ifdef CONFIG_ZORRO
2625         error |= zorro_register_driver(&cirrusfb_zorro_driver);
2626 #endif
2627 #ifdef CONFIG_PCI
2628         error |= pci_register_driver(&cirrusfb_pci_driver);
2629 #endif
2630         return error;
2631 }
2632
2633
2634
2635 #ifndef MODULE
2636 static int __init cirrusfb_setup(char *options) {
2637         char *this_opt, s[32];
2638         int i;
2639
2640         DPRINTK ("ENTER\n");
2641
2642         if (!options || !*options)
2643                 return 0;
2644
2645         while ((this_opt = strsep (&options, ",")) != NULL) {
2646                 if (!*this_opt) continue;
2647
2648                 DPRINTK("cirrusfb_setup: option '%s'\n", this_opt);
2649
2650                 for (i = 0; i < NUM_TOTAL_MODES; i++) {
2651                         sprintf (s, "mode:%s", cirrusfb_predefined[i].name);
2652                         if (strcmp (this_opt, s) == 0)
2653                                 cirrusfb_def_mode = i;
2654                 }
2655                 if (!strcmp(this_opt, "noaccel"))
2656                         noaccel = 1;
2657         }
2658         return 0;
2659 }
2660 #endif
2661
2662
2663     /*
2664      *  Modularization
2665      */
2666
2667 MODULE_AUTHOR("Copyright 1999,2000 Jeff Garzik <jgarzik@pobox.com>");
2668 MODULE_DESCRIPTION("Accelerated FBDev driver for Cirrus Logic chips");
2669 MODULE_LICENSE("GPL");
2670
2671 static void __exit cirrusfb_exit (void)
2672 {
2673 #ifdef CONFIG_PCI
2674         pci_unregister_driver(&cirrusfb_pci_driver);
2675 #endif
2676 #ifdef CONFIG_ZORRO
2677         zorro_unregister_driver(&cirrusfb_zorro_driver);
2678 #endif
2679 }
2680
2681 module_init(cirrusfb_init);
2682
2683 #ifdef MODULE
2684 module_exit(cirrusfb_exit);
2685 #endif
2686
2687
2688 /**********************************************************************/
2689 /* about the following functions - I have used the same names for the */
2690 /* functions as Markus Wild did in his Retina driver for NetBSD as    */
2691 /* they just made sense for this purpose. Apart from that, I wrote    */
2692 /* these functions myself.                                            */
2693 /**********************************************************************/
2694
2695 /*** WGen() - write into one of the external/general registers ***/
2696 static void WGen (const struct cirrusfb_info *cinfo,
2697                   int regnum, unsigned char val)
2698 {
2699         unsigned long regofs = 0;
2700
2701         if (cinfo->btype == BT_PICASSO) {
2702                 /* Picasso II specific hack */
2703 /*              if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D || regnum == CL_VSSM2) */
2704                 if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D)
2705                         regofs = 0xfff;
2706         }
2707
2708         vga_w (cinfo->regbase, regofs + regnum, val);
2709 }
2710
2711 /*** RGen() - read out one of the external/general registers ***/
2712 static unsigned char RGen (const struct cirrusfb_info *cinfo, int regnum)
2713 {
2714         unsigned long regofs = 0;
2715
2716         if (cinfo->btype == BT_PICASSO) {
2717                 /* Picasso II specific hack */
2718 /*              if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D || regnum == CL_VSSM2) */
2719                 if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D)
2720                         regofs = 0xfff;
2721         }
2722
2723         return vga_r (cinfo->regbase, regofs + regnum);
2724 }
2725
2726 /*** AttrOn() - turn on VideoEnable for Attribute controller ***/
2727 static void AttrOn (const struct cirrusfb_info *cinfo)
2728 {
2729         assert (cinfo != NULL);
2730
2731         DPRINTK ("ENTER\n");
2732
2733         if (vga_rcrt (cinfo->regbase, CL_CRT24) & 0x80) {
2734                 /* if we're just in "write value" mode, write back the */
2735                 /* same value as before to not modify anything */
2736                 vga_w (cinfo->regbase, VGA_ATT_IW,
2737                        vga_r (cinfo->regbase, VGA_ATT_R));
2738         }
2739         /* turn on video bit */
2740 /*      vga_w (cinfo->regbase, VGA_ATT_IW, 0x20); */
2741         vga_w (cinfo->regbase, VGA_ATT_IW, 0x33);
2742
2743         /* dummy write on Reg0 to be on "write index" mode next time */
2744         vga_w (cinfo->regbase, VGA_ATT_IW, 0x00);
2745
2746         DPRINTK ("EXIT\n");
2747 }
2748
2749 /*** WHDR() - write into the Hidden DAC register ***/
2750 /* as the HDR is the only extension register that requires special treatment
2751  * (the other extension registers are accessible just like the "ordinary"
2752  * registers of their functional group) here is a specialized routine for
2753  * accessing the HDR
2754  */
2755 static void WHDR (const struct cirrusfb_info *cinfo, unsigned char val)
2756 {
2757         unsigned char dummy;
2758
2759         if (cinfo->btype == BT_PICASSO) {
2760                 /* Klaus' hint for correct access to HDR on some boards */
2761                 /* first write 0 to pixel mask (3c6) */
2762                 WGen (cinfo, VGA_PEL_MSK, 0x00);
2763                 udelay (200);
2764                 /* next read dummy from pixel address (3c8) */
2765                 dummy = RGen (cinfo, VGA_PEL_IW);
2766                 udelay (200);
2767         }
2768         /* now do the usual stuff to access the HDR */
2769
2770         dummy = RGen (cinfo, VGA_PEL_MSK);
2771         udelay (200);
2772         dummy = RGen (cinfo, VGA_PEL_MSK);
2773         udelay (200);
2774         dummy = RGen (cinfo, VGA_PEL_MSK);
2775         udelay (200);
2776         dummy = RGen (cinfo, VGA_PEL_MSK);
2777         udelay (200);
2778
2779         WGen (cinfo, VGA_PEL_MSK, val);
2780         udelay (200);
2781
2782         if (cinfo->btype == BT_PICASSO) {
2783                 /* now first reset HDR access counter */
2784                 dummy = RGen (cinfo, VGA_PEL_IW);
2785                 udelay (200);
2786
2787                 /* and at the end, restore the mask value */
2788                 /* ## is this mask always 0xff? */
2789                 WGen (cinfo, VGA_PEL_MSK, 0xff);
2790                 udelay (200);
2791         }
2792 }
2793
2794
2795 /*** WSFR() - write to the "special function register" (SFR) ***/
2796 static void WSFR (struct cirrusfb_info *cinfo, unsigned char val)
2797 {
2798 #ifdef CONFIG_ZORRO
2799         assert (cinfo->regbase != NULL);
2800         cinfo->SFR = val;
2801         z_writeb (val, cinfo->regbase + 0x8000);
2802 #endif
2803 }
2804
2805 /* The Picasso has a second register for switching the monitor bit */
2806 static void WSFR2 (struct cirrusfb_info *cinfo, unsigned char val)
2807 {
2808 #ifdef CONFIG_ZORRO
2809         /* writing an arbitrary value to this one causes the monitor switcher */
2810         /* to flip to Amiga display */
2811         assert (cinfo->regbase != NULL);
2812         cinfo->SFR = val;
2813         z_writeb (val, cinfo->regbase + 0x9000);
2814 #endif
2815 }
2816
2817
2818 /*** WClut - set CLUT entry (range: 0..63) ***/
2819 static void WClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char red,
2820             unsigned char green, unsigned char blue)
2821 {
2822         unsigned int data = VGA_PEL_D;
2823
2824         /* address write mode register is not translated.. */
2825         vga_w (cinfo->regbase, VGA_PEL_IW, regnum);
2826
2827         if (cinfo->btype == BT_PICASSO || cinfo->btype == BT_PICASSO4 ||
2828             cinfo->btype == BT_ALPINE || cinfo->btype == BT_GD5480) {
2829                 /* but DAC data register IS, at least for Picasso II */
2830                 if (cinfo->btype == BT_PICASSO)
2831                         data += 0xfff;
2832                 vga_w (cinfo->regbase, data, red);
2833                 vga_w (cinfo->regbase, data, green);
2834                 vga_w (cinfo->regbase, data, blue);
2835         } else {
2836                 vga_w (cinfo->regbase, data, blue);
2837                 vga_w (cinfo->regbase, data, green);
2838                 vga_w (cinfo->regbase, data, red);
2839         }
2840 }
2841
2842
2843 #if 0
2844 /*** RClut - read CLUT entry (range 0..63) ***/
2845 static void RClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char *red,
2846             unsigned char *green, unsigned char *blue)
2847 {
2848         unsigned int data = VGA_PEL_D;
2849
2850         vga_w (cinfo->regbase, VGA_PEL_IR, regnum);
2851
2852         if (cinfo->btype == BT_PICASSO || cinfo->btype == BT_PICASSO4 ||
2853             cinfo->btype == BT_ALPINE || cinfo->btype == BT_GD5480) {
2854                 if (cinfo->btype == BT_PICASSO)
2855                         data += 0xfff;
2856                 *red = vga_r (cinfo->regbase, data);
2857                 *green = vga_r (cinfo->regbase, data);
2858                 *blue = vga_r (cinfo->regbase, data);
2859         } else {
2860                 *blue = vga_r (cinfo->regbase, data);
2861                 *green = vga_r (cinfo->regbase, data);
2862                 *red = vga_r (cinfo->regbase, data);
2863         }
2864 }
2865 #endif
2866
2867
2868 /*******************************************************************
2869         cirrusfb_WaitBLT()
2870
2871         Wait for the BitBLT engine to complete a possible earlier job
2872 *********************************************************************/
2873
2874 /* FIXME: use interrupts instead */
2875 static void cirrusfb_WaitBLT (u8 __iomem *regbase)
2876 {
2877         /* now busy-wait until we're done */
2878         while (vga_rgfx (regbase, CL_GR31) & 0x08)
2879                 /* do nothing */ ;
2880 }
2881
2882 /*******************************************************************
2883         cirrusfb_BitBLT()
2884
2885         perform accelerated "scrolling"
2886 ********************************************************************/
2887
2888 static void cirrusfb_BitBLT (u8 __iomem *regbase, int bits_per_pixel,
2889                              u_short curx, u_short cury, u_short destx, u_short desty,
2890                              u_short width, u_short height, u_short line_length)
2891 {
2892         u_short nwidth, nheight;
2893         u_long nsrc, ndest;
2894         u_char bltmode;
2895
2896         DPRINTK ("ENTER\n");
2897
2898         nwidth = width - 1;
2899         nheight = height - 1;
2900
2901         bltmode = 0x00;
2902         /* if source adr < dest addr, do the Blt backwards */
2903         if (cury <= desty) {
2904                 if (cury == desty) {
2905                         /* if src and dest are on the same line, check x */
2906                         if (curx < destx)
2907                                 bltmode |= 0x01;
2908                 } else
2909                         bltmode |= 0x01;
2910         }
2911         if (!bltmode) {
2912                 /* standard case: forward blitting */
2913                 nsrc = (cury * line_length) + curx;
2914                 ndest = (desty * line_length) + destx;
2915         } else {
2916                 /* this means start addresses are at the end, counting backwards */
2917                 nsrc = cury * line_length + curx + nheight * line_length + nwidth;
2918                 ndest = desty * line_length + destx + nheight * line_length + nwidth;
2919         }
2920
2921         /*
2922            run-down of registers to be programmed:
2923            destination pitch
2924            source pitch
2925            BLT width/height
2926            source start
2927            destination start
2928            BLT mode
2929            BLT ROP
2930            VGA_GFX_SR_VALUE / VGA_GFX_SR_ENABLE: "fill color"
2931            start/stop
2932          */
2933
2934         cirrusfb_WaitBLT(regbase);
2935
2936         /* pitch: set to line_length */
2937         vga_wgfx (regbase, CL_GR24, line_length & 0xff);        /* dest pitch low */
2938         vga_wgfx (regbase, CL_GR25, (line_length >> 8));        /* dest pitch hi */
2939         vga_wgfx (regbase, CL_GR26, line_length & 0xff);        /* source pitch low */
2940         vga_wgfx (regbase, CL_GR27, (line_length >> 8));        /* source pitch hi */
2941
2942         /* BLT width: actual number of pixels - 1 */
2943         vga_wgfx (regbase, CL_GR20, nwidth & 0xff);     /* BLT width low */
2944         vga_wgfx (regbase, CL_GR21, (nwidth >> 8));     /* BLT width hi */
2945
2946         /* BLT height: actual number of lines -1 */
2947         vga_wgfx (regbase, CL_GR22, nheight & 0xff);    /* BLT height low */
2948         vga_wgfx (regbase, CL_GR23, (nheight >> 8));    /* BLT width hi */
2949
2950         /* BLT destination */
2951         vga_wgfx (regbase, CL_GR28, (u_char) (ndest & 0xff));   /* BLT dest low */
2952         vga_wgfx (regbase, CL_GR29, (u_char) (ndest >> 8));     /* BLT dest mid */
2953         vga_wgfx (regbase, CL_GR2A, (u_char) (ndest >> 16));    /* BLT dest hi */
2954
2955         /* BLT source */
2956         vga_wgfx (regbase, CL_GR2C, (u_char) (nsrc & 0xff));    /* BLT src low */
2957         vga_wgfx (regbase, CL_GR2D, (u_char) (nsrc >> 8));              /* BLT src mid */
2958         vga_wgfx (regbase, CL_GR2E, (u_char) (nsrc >> 16));     /* BLT src hi */
2959
2960         /* BLT mode */
2961         vga_wgfx (regbase, CL_GR30, bltmode);   /* BLT mode */
2962
2963         /* BLT ROP: SrcCopy */
2964         vga_wgfx (regbase, CL_GR32, 0x0d);              /* BLT ROP */
2965
2966         /* and finally: GO! */
2967         vga_wgfx (regbase, CL_GR31, 0x02);              /* BLT Start/status */
2968
2969         DPRINTK ("EXIT\n");
2970 }
2971
2972
2973 /*******************************************************************
2974         cirrusfb_RectFill()
2975
2976         perform accelerated rectangle fill
2977 ********************************************************************/
2978
2979 static void cirrusfb_RectFill (u8 __iomem *regbase, int bits_per_pixel,
2980                      u_short x, u_short y, u_short width, u_short height,
2981                      u_char color, u_short line_length)
2982 {
2983         u_short nwidth, nheight;
2984         u_long ndest;
2985         u_char op;
2986
2987         DPRINTK ("ENTER\n");
2988
2989         nwidth = width - 1;
2990         nheight = height - 1;
2991
2992         ndest = (y * line_length) + x;
2993
2994         cirrusfb_WaitBLT(regbase);
2995
2996         /* pitch: set to line_length */
2997         vga_wgfx (regbase, CL_GR24, line_length & 0xff);        /* dest pitch low */
2998         vga_wgfx (regbase, CL_GR25, (line_length >> 8));        /* dest pitch hi */
2999         vga_wgfx (regbase, CL_GR26, line_length & 0xff);        /* source pitch low */
3000         vga_wgfx (regbase, CL_GR27, (line_length >> 8));        /* source pitch hi */
3001
3002         /* BLT width: actual number of pixels - 1 */
3003         vga_wgfx (regbase, CL_GR20, nwidth & 0xff);     /* BLT width low */
3004         vga_wgfx (regbase, CL_GR21, (nwidth >> 8));     /* BLT width hi */
3005
3006         /* BLT height: actual number of lines -1 */
3007         vga_wgfx (regbase, CL_GR22, nheight & 0xff);            /* BLT height low */
3008         vga_wgfx (regbase, CL_GR23, (nheight >> 8));            /* BLT width hi */
3009
3010         /* BLT destination */
3011         vga_wgfx (regbase, CL_GR28, (u_char) (ndest & 0xff));   /* BLT dest low */
3012         vga_wgfx (regbase, CL_GR29, (u_char) (ndest >> 8));     /* BLT dest mid */
3013         vga_wgfx (regbase, CL_GR2A, (u_char) (ndest >> 16));            /* BLT dest hi */
3014
3015         /* BLT source: set to 0 (is a dummy here anyway) */
3016         vga_wgfx (regbase, CL_GR2C, 0x00);      /* BLT src low */
3017         vga_wgfx (regbase, CL_GR2D, 0x00);      /* BLT src mid */
3018         vga_wgfx (regbase, CL_GR2E, 0x00);      /* BLT src hi */
3019
3020         /* This is a ColorExpand Blt, using the */
3021         /* same color for foreground and background */
3022         vga_wgfx (regbase, VGA_GFX_SR_VALUE, color);    /* foreground color */
3023         vga_wgfx (regbase, VGA_GFX_SR_ENABLE, color);   /* background color */
3024
3025         op = 0xc0;
3026         if (bits_per_pixel == 16) {
3027                 vga_wgfx (regbase, CL_GR10, color);     /* foreground color */
3028                 vga_wgfx (regbase, CL_GR11, color);     /* background color */
3029                 op = 0x50;
3030                 op = 0xd0;
3031         } else if (bits_per_pixel == 32) {
3032                 vga_wgfx (regbase, CL_GR10, color);     /* foreground color */
3033                 vga_wgfx (regbase, CL_GR11, color);     /* background color */
3034                 vga_wgfx (regbase, CL_GR12, color);     /* foreground color */
3035                 vga_wgfx (regbase, CL_GR13, color);     /* background color */
3036                 vga_wgfx (regbase, CL_GR14, 0); /* foreground color */
3037                 vga_wgfx (regbase, CL_GR15, 0); /* background color */
3038                 op = 0x50;
3039                 op = 0xf0;
3040         }
3041         /* BLT mode: color expand, Enable 8x8 copy (faster?) */
3042         vga_wgfx (regbase, CL_GR30, op);        /* BLT mode */
3043
3044         /* BLT ROP: SrcCopy */
3045         vga_wgfx (regbase, CL_GR32, 0x0d);      /* BLT ROP */
3046
3047         /* and finally: GO! */
3048         vga_wgfx (regbase, CL_GR31, 0x02);      /* BLT Start/status */
3049
3050         DPRINTK ("EXIT\n");
3051 }
3052
3053
3054 /**************************************************************************
3055  * bestclock() - determine closest possible clock lower(?) than the
3056  * desired pixel clock
3057  **************************************************************************/
3058 static void bestclock (long freq, long *best, long *nom,
3059                        long *den, long *div, long maxfreq)
3060 {
3061         long n, h, d, f;
3062
3063         assert (best != NULL);
3064         assert (nom != NULL);
3065         assert (den != NULL);
3066         assert (div != NULL);
3067         assert (maxfreq > 0);
3068
3069         *nom = 0;
3070         *den = 0;
3071         *div = 0;
3072
3073         DPRINTK ("ENTER\n");
3074
3075         if (freq < 8000)
3076                 freq = 8000;
3077
3078         if (freq > maxfreq)
3079                 freq = maxfreq;
3080
3081         *best = 0;
3082         f = freq * 10;
3083
3084         for (n = 32; n < 128; n++) {
3085                 d = (143181 * n) / f;
3086                 if ((d >= 7) && (d <= 63)) {
3087                         if (d > 31)
3088                                 d = (d / 2) * 2;
3089                         h = (14318 * n) / d;
3090                         if (abs (h - freq) < abs (*best - freq)) {
3091                                 *best = h;
3092                                 *nom = n;
3093                                 if (d < 32) {
3094                                         *den = d;
3095                                         *div = 0;
3096                                 } else {
3097                                         *den = d / 2;
3098                                         *div = 1;
3099                                 }
3100                         }
3101                 }
3102                 d = ((143181 * n) + f - 1) / f;
3103                 if ((d >= 7) && (d <= 63)) {
3104                         if (d > 31)
3105                                 d = (d / 2) * 2;
3106                         h = (14318 * n) / d;
3107                         if (abs (h - freq) < abs (*best - freq)) {
3108                                 *best = h;
3109                                 *nom = n;
3110                                 if (d < 32) {
3111                                         *den = d;
3112                                         *div = 0;
3113                                 } else {
3114                                         *den = d / 2;
3115                                         *div = 1;
3116                                 }
3117                         }
3118                 }
3119         }
3120
3121         DPRINTK ("Best possible values for given frequency:\n");
3122         DPRINTK ("        best: %ld kHz  nom: %ld  den: %ld  div: %ld\n",
3123                  freq, *nom, *den, *div);
3124
3125         DPRINTK ("EXIT\n");
3126 }
3127
3128
3129 /* -------------------------------------------------------------------------
3130  *
3131  * debugging functions
3132  *
3133  * -------------------------------------------------------------------------
3134  */
3135
3136 #ifdef CIRRUSFB_DEBUG
3137
3138 /**
3139  * cirrusfb_dbg_print_byte
3140  * @name: name associated with byte value to be displayed
3141  * @val: byte value to be displayed
3142  *
3143  * DESCRIPTION:
3144  * Display an indented string, along with a hexidecimal byte value, and
3145  * its decoded bits.  Bits 7 through 0 are listed in left-to-right
3146  * order.
3147  */
3148
3149 static
3150 void cirrusfb_dbg_print_byte (const char *name, unsigned char val)
3151 {
3152         DPRINTK ("%8s = 0x%02X (bits 7-0: %c%c%c%c%c%c%c%c)\n",
3153                  name, val,
3154                  val & 0x80 ? '1' : '0',
3155                  val & 0x40 ? '1' : '0',
3156                  val & 0x20 ? '1' : '0',
3157                  val & 0x10 ? '1' : '0',
3158                  val & 0x08 ? '1' : '0',
3159                  val & 0x04 ? '1' : '0',
3160                  val & 0x02 ? '1' : '0',
3161                  val & 0x01 ? '1' : '0');
3162 }
3163
3164
3165 /**
3166  * cirrusfb_dbg_print_regs
3167  * @base: If using newmmio, the newmmio base address, otherwise %NULL
3168  * @reg_class: type of registers to read: %CRT, or %SEQ
3169  *
3170  * DESCRIPTION:
3171  * Dumps the given list of VGA CRTC registers.  If @base is %NULL,
3172  * old-style I/O ports are queried for information, otherwise MMIO is
3173  * used at the given @base address to query the information.
3174  */
3175
3176 static
3177 void cirrusfb_dbg_print_regs (caddr_t regbase, cirrusfb_dbg_reg_class_t reg_class,...)
3178 {
3179         va_list list;
3180         unsigned char val = 0;
3181         unsigned reg;
3182         char *name;
3183
3184         va_start (list, reg_class);
3185
3186         name = va_arg (list, char *);
3187         while (name != NULL) {
3188                 reg = va_arg (list, int);
3189
3190                 switch (reg_class) {
3191                 case CRT:
3192                         val = vga_rcrt (regbase, (unsigned char) reg);
3193                         break;
3194                 case SEQ:
3195                         val = vga_rseq (regbase, (unsigned char) reg);
3196                         break;
3197                 default:
3198                         /* should never occur */
3199                         assert (FALSE);
3200                         break;
3201                 }
3202
3203                 cirrusfb_dbg_print_byte (name, val);
3204
3205                 name = va_arg (list, char *);
3206         }
3207
3208         va_end (list);
3209 }
3210
3211
3212 /**
3213  * cirrusfb_dump
3214  * @cirrusfbinfo:
3215  *
3216  * DESCRIPTION:
3217  */
3218
3219 static
3220 void cirrusfb_dump (void)
3221 {
3222         cirrusfb_dbg_reg_dump (NULL);
3223 }
3224
3225
3226 /**
3227  * cirrusfb_dbg_reg_dump
3228  * @base: If using newmmio, the newmmio base address, otherwise %NULL
3229  *
3230  * DESCRIPTION:
3231  * Dumps a list of interesting VGA and CIRRUSFB registers.  If @base is %NULL,
3232  * old-style I/O ports are queried for information, otherwise MMIO is
3233  * used at the given @base address to query the information.
3234  */
3235
3236 static
3237 void cirrusfb_dbg_reg_dump (caddr_t regbase)
3238 {
3239         DPRINTK ("CIRRUSFB VGA CRTC register dump:\n");
3240
3241         cirrusfb_dbg_print_regs (regbase, CRT,
3242                            "CR00", 0x00,
3243                            "CR01", 0x01,
3244                            "CR02", 0x02,
3245                            "CR03", 0x03,
3246                            "CR04", 0x04,
3247                            "CR05", 0x05,
3248                            "CR06", 0x06,
3249                            "CR07", 0x07,
3250                            "CR08", 0x08,
3251                            "CR09", 0x09,
3252                            "CR0A", 0x0A,
3253                            "CR0B", 0x0B,
3254                            "CR0C", 0x0C,
3255                            "CR0D", 0x0D,
3256                            "CR0E", 0x0E,
3257                            "CR0F", 0x0F,
3258                            "CR10", 0x10,
3259                            "CR11", 0x11,
3260                            "CR12", 0x12,
3261                            "CR13", 0x13,
3262                            "CR14", 0x14,
3263                            "CR15", 0x15,
3264                            "CR16", 0x16,
3265                            "CR17", 0x17,
3266                            "CR18", 0x18,
3267                            "CR22", 0x22,
3268                            "CR24", 0x24,
3269                            "CR26", 0x26,
3270                            "CR2D", 0x2D,
3271                            "CR2E", 0x2E,
3272                            "CR2F", 0x2F,
3273                            "CR30", 0x30,
3274                            "CR31", 0x31,
3275                            "CR32", 0x32,
3276                            "CR33", 0x33,
3277                            "CR34", 0x34,
3278                            "CR35", 0x35,
3279                            "CR36", 0x36,
3280                            "CR37", 0x37,
3281                            "CR38", 0x38,
3282                            "CR39", 0x39,
3283                            "CR3A", 0x3A,
3284                            "CR3B", 0x3B,
3285                            "CR3C", 0x3C,
3286                            "CR3D", 0x3D,
3287                            "CR3E", 0x3E,
3288                            "CR3F", 0x3F,
3289                            NULL);
3290
3291         DPRINTK ("\n");
3292
3293         DPRINTK ("CIRRUSFB VGA SEQ register dump:\n");
3294
3295         cirrusfb_dbg_print_regs (regbase, SEQ,
3296                            "SR00", 0x00,
3297                            "SR01", 0x01,
3298                            "SR02", 0x02,
3299                            "SR03", 0x03,
3300                            "SR04", 0x04,
3301                            "SR08", 0x08,
3302                            "SR09", 0x09,
3303                            "SR0A", 0x0A,
3304                            "SR0B", 0x0B,
3305                            "SR0D", 0x0D,
3306                            "SR10", 0x10,
3307                            "SR11", 0x11,
3308                            "SR12", 0x12,
3309                            "SR13", 0x13,
3310                            "SR14", 0x14,
3311                            "SR15", 0x15,
3312                            "SR16", 0x16,
3313                            "SR17", 0x17,
3314                            "SR18", 0x18,
3315                            "SR19", 0x19,
3316                            "SR1A", 0x1A,
3317                            "SR1B", 0x1B,
3318                            "SR1C", 0x1C,
3319                            "SR1D", 0x1D,
3320                            "SR1E", 0x1E,
3321                            "SR1F", 0x1F,
3322                            NULL);
3323
3324         DPRINTK ("\n");
3325 }
3326
3327 #endif                          /* CIRRUSFB_DEBUG */
3328