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