drivers/video/riva/fbdev.c

   1 /*
   2  * linux/drivers/video/riva/fbdev.c - nVidia RIVA 128/TNT/TNT2 fb driver
   3  *
   4  * Maintained by Ani Joshi <ajoshi@shell.unixbox.com>
   5  *
   6  * Copyright 1999-2000 Jeff Garzik
   7  *
   8  * Contributors:
   9  *
  10  *      Ani Joshi:  Lots of debugging and cleanup work, really helped
  11  *      get the driver going
  12  *
  13  *      Ferenc Bakonyi:  Bug fixes, cleanup, modularization
  14  *
  15  *      Jindrich Makovicka:  Accel code help, hw cursor, mtrr
  16  *
  17  *      Paul Richards:  Bug fixes, updates
  18  *
  19  * Initial template from skeletonfb.c, created 28 Dec 1997 by Geert Uytterhoeven
  20  * Includes riva_hw.c from nVidia, see copyright below.
  21  * KGI code provided the basis for state storage, init, and mode switching.
  22  *
  23  * This file is subject to the terms and conditions of the GNU General Public
  24  * License.  See the file COPYING in the main directory of this archive
  25  * for more details.
  26  *
  27  * Known bugs and issues:
  28  *      restoring text mode fails
  29  *      doublescan modes are broken
  30  */
  31
  32 #include <linux/config.h>
  33 #include <linux/module.h>
  34 #include <linux/kernel.h>
  35 #include <linux/errno.h>
  36 #include <linux/string.h>
  37 #include <linux/mm.h>
  38 #include <linux/tty.h>
  39 #include <linux/slab.h>
  40 #include <linux/delay.h>
  41 #include <linux/fb.h>
  42 #include <linux/init.h>
  43 #include <linux/pci.h>
  44 #ifdef CONFIG_MTRR
  45 #include <asm/mtrr.h>
  46 #endif
  47 #ifdef CONFIG_PPC_OF
  48 #include <asm/prom.h>
  49 #include <asm/pci-bridge.h>
  50 #endif
  51
  52 #include "rivafb.h"
  53 #include "nvreg.h"
  54
  55 #ifndef CONFIG_PCI              /* sanity check */
  56 #error This driver requires PCI support.
  57 #endif
  58
  59 /* version number of this driver */
  60 #define RIVAFB_VERSION "0.9.5b"
  61
  62 /* ------------------------------------------------------------------------- *
  63  *
  64  * various helpful macros and constants
  65  *
  66  * ------------------------------------------------------------------------- */
  67
  68 #undef RIVAFBDEBUG
  69 #ifdef RIVAFBDEBUG
  70 #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
  71 #else
  72 #define DPRINTK(fmt, args...)
  73 #endif
  74
  75 #ifndef RIVA_NDEBUG
  76 #define assert(expr) \
  77         if(!(expr)) { \
  78         printk( "Assertion failed! %s,%s,%s,line=%d\n",\
  79         #expr,__FILE__,__FUNCTION__,__LINE__); \
  80         BUG(); \
  81         }
  82 #else
  83 #define assert(expr)
  84 #endif
  85
  86 #define PFX "rivafb: "
  87
  88 /* macro that allows you to set overflow bits */
  89 #define SetBitField(value,from,to) SetBF(to,GetBF(value,from))
  90 #define SetBit(n)               (1<<(n))
  91 #define Set8Bits(value)         ((value)&0xff)
  92
  93 /* HW cursor parameters */
  94 #define MAX_CURS                32
  95
  96 /* ------------------------------------------------------------------------- *
  97  *
  98  * prototypes
  99  *
 100  * ------------------------------------------------------------------------- */
 101
 102 static int rivafb_blank(int blank, struct fb_info *info);
 103
 104 /* ------------------------------------------------------------------------- *
 105  *
 106  * card identification
 107  *
 108  * ------------------------------------------------------------------------- */
 109
 110 enum riva_chips {
 111         CH_RIVA_128 = 0,
 112         CH_RIVA_TNT,
 113         CH_RIVA_TNT2,
 114         CH_RIVA_UTNT2,
 115         CH_RIVA_VTNT2,
 116         CH_RIVA_UVTNT2,
 117         CH_RIVA_ITNT2,
 118         CH_GEFORCE_SDR,
 119         CH_GEFORCE_DDR,
 120         CH_QUADRO,
 121         CH_GEFORCE2_MX,
 122         CH_GEFORCE2_MX2,
 123         CH_GEFORCE2_GO,
 124         CH_QUADRO2_MXR,
 125         CH_GEFORCE2_GTS,
 126         CH_GEFORCE2_GTS2,
 127         CH_GEFORCE2_ULTRA,
 128         CH_QUADRO2_PRO,
 129         CH_GEFORCE4_MX_460,
 130         CH_GEFORCE4_MX_440,
 131         CH_GEFORCE4_MX_420,
 132         CH_GEFORCE4_440_GO,
 133         CH_GEFORCE4_420_GO,
 134         CH_GEFORCE4_420_GO_M32,
 135         CH_QUADRO4_500XGL,
 136         CH_GEFORCE4_440_GO_M64,
 137         CH_QUADRO4_200,
 138         CH_QUADRO4_550XGL,
 139         CH_QUADRO4_500_GOGL,
 140         CH_IGEFORCE2,
 141         CH_GEFORCE3,
 142         CH_GEFORCE3_1,
 143         CH_GEFORCE3_2,
 144         CH_QUADRO_DDC,
 145         CH_GEFORCE4_TI_4600,
 146         CH_GEFORCE4_TI_4400,
 147         CH_GEFORCE4_TI_4200,
 148         CH_QUADRO4_900XGL,
 149         CH_QUADRO4_750XGL,
 150         CH_QUADRO4_700XGL
 151 };
 152
 153 /* directly indexed by riva_chips enum, above */
 154 static struct riva_chip_info {
 155         const char *name;
 156         unsigned arch_rev;
 157 } riva_chip_info[] __initdata = {
 158         { "RIVA-128", NV_ARCH_03 },
 159         { "RIVA-TNT", NV_ARCH_04 },
 160         { "RIVA-TNT2", NV_ARCH_04 },
 161         { "RIVA-UTNT2", NV_ARCH_04 },
 162         { "RIVA-VTNT2", NV_ARCH_04 },
 163         { "RIVA-UVTNT2", NV_ARCH_04 },
 164         { "RIVA-ITNT2", NV_ARCH_04 },
 165         { "GeForce-SDR", NV_ARCH_10 },
 166         { "GeForce-DDR", NV_ARCH_10 },
 167         { "Quadro", NV_ARCH_10 },
 168         { "GeForce2-MX", NV_ARCH_10 },
 169         { "GeForce2-MX", NV_ARCH_10 },
 170         { "GeForce2-GO", NV_ARCH_10 },
 171         { "Quadro2-MXR", NV_ARCH_10 },
 172         { "GeForce2-GTS", NV_ARCH_10 },
 173         { "GeForce2-GTS", NV_ARCH_10 },
 174         { "GeForce2-ULTRA", NV_ARCH_10 },
 175         { "Quadro2-PRO", NV_ARCH_10 },
 176         { "GeForce4-MX-460", NV_ARCH_20 },
 177         { "GeForce4-MX-440", NV_ARCH_20 },
 178         { "GeForce4-MX-420", NV_ARCH_20 },
 179         { "GeForce4-440-GO", NV_ARCH_20 },
 180         { "GeForce4-420-GO", NV_ARCH_20 },
 181         { "GeForce4-420-GO-M32", NV_ARCH_20 },
 182         { "Quadro4-500-XGL", NV_ARCH_20 },
 183         { "GeForce4-440-GO-M64", NV_ARCH_20 },
 184         { "Quadro4-200", NV_ARCH_20 },
 185         { "Quadro4-550-XGL", NV_ARCH_20 },
 186         { "Quadro4-500-GOGL", NV_ARCH_20 },
 187         { "GeForce2", NV_ARCH_20 },
 188         { "GeForce3", NV_ARCH_20 },
 189         { "GeForce3 Ti 200", NV_ARCH_20 },
 190         { "GeForce3 Ti 500", NV_ARCH_20 },
 191         { "Quadro DDC", NV_ARCH_20 },
 192         { "GeForce4 Ti 4600", NV_ARCH_20 },
 193         { "GeForce4 Ti 4400", NV_ARCH_20 },
 194         { "GeForce4 Ti 4200", NV_ARCH_20 },
 195         { "Quadro4-900-XGL", NV_ARCH_20 },
 196         { "Quadro4-750-XGL", NV_ARCH_20 },
 197         { "Quadro4-700-XGL", NV_ARCH_20 }
 198 };
 199
 200 static struct pci_device_id rivafb_pci_tbl[] = {
 201         { PCI_VENDOR_ID_NVIDIA_SGS, PCI_DEVICE_ID_NVIDIA_SGS_RIVA128,
 202           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RIVA_128 },
 203         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_TNT,
 204           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RIVA_TNT },
 205         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_TNT2,
 206           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RIVA_TNT2 },
 207         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_UTNT2,
 208           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RIVA_UTNT2 },
 209         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_VTNT2,
 210           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RIVA_VTNT2 },
 211         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_UVTNT2,
 212           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RIVA_VTNT2 },
 213         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_ITNT2,
 214           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RIVA_ITNT2 },
 215         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE_SDR,
 216           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE_SDR },
 217         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE_DDR,
 218           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE_DDR },
 219         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO,
 220           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO },
 221         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_MX,
 222           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE2_MX },
 223         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_MX2,
 224           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE2_MX2 },
 225         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_GO,
 226           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE2_GO },
 227         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO2_MXR,
 228           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO2_MXR },
 229         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_GTS,
 230           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE2_GTS },
 231         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_GTS2,
 232           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE2_GTS2 },
 233         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE2_ULTRA,
 234           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE2_ULTRA },
 235         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO2_PRO,
 236           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO2_PRO },
 237         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_460,
 238           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_MX_460 },
 239         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_440,
 240           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_MX_440 },
 241         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_MX_420,
 242           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_MX_420 },
 243         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_440_GO,
 244           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_440_GO },
 245         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_420_GO,
 246           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_420_GO },
 247         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_420_GO_M32,
 248           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_420_GO_M32 },
 249         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_500XGL,
 250           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO4_500XGL },
 251         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_440_GO_M64,
 252           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_440_GO_M64 },
 253         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_200,
 254           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO4_200 },
 255         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_550XGL,
 256           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO4_550XGL },
 257         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_500_GOGL,
 258           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO4_500_GOGL },
 259         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_IGEFORCE2,
 260           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_IGEFORCE2 },
 261         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE3,
 262           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE3 },
 263         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE3_1,
 264           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE3_1 },
 265         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE3_2,
 266           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE3_2 },
 267         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO_DDC,
 268           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO_DDC },
 269         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4600,
 270           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_TI_4600 },
 271         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4400,
 272           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_TI_4400 },
 273         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4200,
 274           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_GEFORCE4_TI_4200 },
 275         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_900XGL,
 276           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO4_900XGL },
 277         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_750XGL,
 278           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO4_750XGL },
 279         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_QUADRO4_700XGL,
 280           PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_QUADRO4_700XGL },
 281         { 0, } /* terminate list */
 282 };
 283 MODULE_DEVICE_TABLE(pci, rivafb_pci_tbl);
 284
 285 /* ------------------------------------------------------------------------- *
 286  *
 287  * global variables
 288  *
 289  * ------------------------------------------------------------------------- */
 290
 291 /* command line data, set in rivafb_setup() */
 292 static u32 pseudo_palette[17];
 293 static int flatpanel __initdata = -1; /* Autodetect later */
 294 static int forceCRTC __initdata = -1;
 295 #ifdef CONFIG_MTRR
 296 static int nomtrr __initdata = 0;
 297 #endif
 298
 299 #ifndef MODULE
 300 static char *mode_option __initdata = NULL;
 301 #endif
 302
 303 static struct fb_fix_screeninfo rivafb_fix = {
 304         .id             = "nVidia",
 305         .type           = FB_TYPE_PACKED_PIXELS,
 306         .xpanstep       = 1,
 307         .ypanstep       = 1,
 308 };
 309
 310 static struct fb_var_screeninfo rivafb_default_var = {
 311         .xres           = 640,
 312         .yres           = 480,
 313         .xres_virtual   = 640,
 314         .yres_virtual   = 480,
 315         .bits_per_pixel = 8,
 316         .red            = {0, 8, 0},
 317         .green          = {0, 8, 0},
 318         .blue           = {0, 8, 0},
 319         .transp         = {0, 0, 0},
 320         .activate       = FB_ACTIVATE_NOW,
 321         .height         = -1,
 322         .width          = -1,
 323         .accel_flags    = FB_ACCELF_TEXT,
 324         .pixclock       = 39721,
 325         .left_margin    = 40,
 326         .right_margin   = 24,
 327         .upper_margin   = 32,
 328         .lower_margin   = 11,
 329         .hsync_len      = 96,
 330         .vsync_len      = 2,
 331         .vmode          = FB_VMODE_NONINTERLACED
 332 };
 333
 334 /* from GGI */
 335 static const struct riva_regs reg_template = {
 336         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,        /* ATTR */
 337          0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 338          0x41, 0x01, 0x0F, 0x00, 0x00},
 339         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        /* CRT  */
 340          0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
 341          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3,        /* 0x10 */
 342          0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 343          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        /* 0x20 */
 344          0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 345          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        /* 0x30 */
 346          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 347          0x00,                                                  /* 0x40 */
 348          },
 349         {0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,        /* GRA  */
 350          0xFF},
 351         {0x03, 0x01, 0x0F, 0x00, 0x0E},                         /* SEQ  */
 352         0xEB                                                    /* MISC */
 353 };
 354
 355 /* ------------------------------------------------------------------------- *
 356  *
 357  * MMIO access macros
 358  *
 359  * ------------------------------------------------------------------------- */
 360
 361 static inline void CRTCout(struct riva_par *par, unsigned char index,
 362                            unsigned char val)
 363 {
 364         VGA_WR08(par->riva.PCIO, 0x3d4, index);
 365         VGA_WR08(par->riva.PCIO, 0x3d5, val);
 366 }
 367
 368 static inline unsigned char CRTCin(struct riva_par *par,
 369                                    unsigned char index)
 370 {
 371         VGA_WR08(par->riva.PCIO, 0x3d4, index);
 372         return (VGA_RD08(par->riva.PCIO, 0x3d5));
 373 }
 374
 375 static inline void GRAout(struct riva_par *par, unsigned char index,
 376                           unsigned char val)
 377 {
 378         VGA_WR08(par->riva.PVIO, 0x3ce, index);
 379         VGA_WR08(par->riva.PVIO, 0x3cf, val);
 380 }
 381
 382 static inline unsigned char GRAin(struct riva_par *par,
 383                                   unsigned char index)
 384 {
 385         VGA_WR08(par->riva.PVIO, 0x3ce, index);
 386         return (VGA_RD08(par->riva.PVIO, 0x3cf));
 387 }
 388
 389 static inline void SEQout(struct riva_par *par, unsigned char index,
 390                           unsigned char val)
 391 {
 392         VGA_WR08(par->riva.PVIO, 0x3c4, index);
 393         VGA_WR08(par->riva.PVIO, 0x3c5, val);
 394 }
 395
 396 static inline unsigned char SEQin(struct riva_par *par,
 397                                   unsigned char index)
 398 {
 399         VGA_WR08(par->riva.PVIO, 0x3c4, index);
 400         return (VGA_RD08(par->riva.PVIO, 0x3c5));
 401 }
 402
 403 static inline void ATTRout(struct riva_par *par, unsigned char index,
 404                            unsigned char val)
 405 {
 406         VGA_WR08(par->riva.PCIO, 0x3c0, index);
 407         VGA_WR08(par->riva.PCIO, 0x3c0, val);
 408 }
 409
 410 static inline unsigned char ATTRin(struct riva_par *par,
 411                                    unsigned char index)
 412 {
 413         VGA_WR08(par->riva.PCIO, 0x3c0, index);
 414         return (VGA_RD08(par->riva.PCIO, 0x3c1));
 415 }
 416
 417 static inline void MISCout(struct riva_par *par, unsigned char val)
 418 {
 419         VGA_WR08(par->riva.PVIO, 0x3c2, val);
 420 }
 421
 422 static inline unsigned char MISCin(struct riva_par *par)
 423 {
 424         return (VGA_RD08(par->riva.PVIO, 0x3cc));
 425 }
 426
 427 static u8 byte_rev[256] = {
 428         0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
 429         0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
 430         0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
 431         0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
 432         0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
 433         0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
 434         0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
 435         0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
 436         0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
 437         0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
 438         0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
 439         0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
 440         0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
 441         0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
 442         0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
 443         0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
 444         0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
 445         0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
 446         0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
 447         0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
 448         0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
 449         0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
 450         0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
 451         0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
 452         0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
 453         0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
 454         0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
 455         0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
 456         0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
 457         0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
 458         0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
 459         0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
 460 };
 461
 462 static inline void reverse_order(u32 *l)
 463 {
 464         u8 *a = (u8 *)l;
 465         *a = byte_rev[*a], a++;
 466         *a = byte_rev[*a], a++;
 467         *a = byte_rev[*a], a++;
 468         *a = byte_rev[*a];
 469 }
 470
 471 /* ------------------------------------------------------------------------- *
 472  *
 473  * cursor stuff
 474  *
 475  * ------------------------------------------------------------------------- */
 476
 477 /**
 478  * rivafb_load_cursor_image - load cursor image to hardware
 479  * @data: address to monochrome bitmap (1 = foreground color, 0 = background)
 480  * @par:  pointer to private data
 481  * @w:    width of cursor image in pixels
 482  * @h:    height of cursor image in scanlines
 483  * @bg:   background color (ARGB1555) - alpha bit determines opacity
 484  * @fg:   foreground color (ARGB1555)
 485  *
 486  * DESCRIPTiON:
 487  * Loads cursor image based on a monochrome source and mask bitmap.  The
 488  * image bits determines the color of the pixel, 0 for background, 1 for
 489  * foreground.  Only the affected region (as determined by @w and @h
 490  * parameters) will be updated.
 491  *
 492  * CALLED FROM:
 493  * rivafb_cursor()
 494  */
 495 static void rivafb_load_cursor_image(struct riva_par *par, u8 *data8,
 496                                      u8 *mask8, u16 bg, u16 fg, u32 w, u32 h)
 497 {
 498         int i, j, k = 0;
 499         u32 b, m, tmp;
 500         u32 *data = (u32 *)data8;
 501         u32 *mask = (u32 *)mask8;
 502
 503         for (i = 0; i < h; i++) {
 504                 b = *data++;
 505                 m = *mask++;
 506                 reverse_order(&b);
 507
 508                 for (j = 0; j < w/2; j++) {
 509                         tmp = 0;
 510 #if defined (__BIG_ENDIAN)
 511                         if (m & (1 << 31)) {
 512                                 fg |= 1 << 15;
 513                                 bg |= 1 << 15;
 514                         }
 515                         tmp = (b & (1 << 31)) ? fg << 16 : bg << 16;
 516                         b <<= 1;
 517                         m <<= 1;
 518
 519                         if (m & (1 << 31)) {
 520                                 fg |= 1 << 15;
 521                                 bg |= 1 << 15;
 522                         }
 523                         tmp |= (b & (1 << 31)) ? fg : bg;
 524                         b <<= 1;
 525                         m <<= 1;
 526 #else
 527                         if (m & 1) {
 528                                 fg |= 1 << 15;
 529                                 bg |= 1 << 15;
 530                         }
 531                         tmp = (b & 1) ? fg : bg;
 532                         b >>= 1;
 533                         m >>= 1;
 534
 535                         if (m & 1) {
 536                                 fg |= 1 << 15;
 537                                 bg |= 1 << 15;
 538                         }
 539                         tmp |= (b & 1) ? fg << 16 : bg << 16;
 540                         b >>= 1;
 541                         m >>= 1;
 542 #endif
 543                         writel(tmp, par->riva.CURSOR + k++);
 544                 }
 545                 k += (MAX_CURS - w)/2;
 546         }
 547 }
 548
 549 /* ------------------------------------------------------------------------- *
 550  *
 551  * general utility functions
 552  *
 553  * ------------------------------------------------------------------------- */
 554
 555 /**
 556  * riva_wclut - set CLUT entry
 557  * @chip: pointer to RIVA_HW_INST object
 558  * @regnum: register number
 559  * @red: red component
 560  * @green: green component
 561  * @blue: blue component
 562  *
 563  * DESCRIPTION:
 564  * Sets color register @regnum.
 565  *
 566  * CALLED FROM:
 567  * rivafb_setcolreg()
 568  */
 569 static void riva_wclut(RIVA_HW_INST *chip,
 570                        unsigned char regnum, unsigned char red,
 571                        unsigned char green, unsigned char blue)
 572 {
 573         VGA_WR08(chip->PDIO, 0x3c8, regnum);
 574         VGA_WR08(chip->PDIO, 0x3c9, red);
 575         VGA_WR08(chip->PDIO, 0x3c9, green);
 576         VGA_WR08(chip->PDIO, 0x3c9, blue);
 577 }
 578
 579 /**
 580  * riva_rclut - read fromCLUT register
 581  * @chip: pointer to RIVA_HW_INST object
 582  * @regnum: register number
 583  * @red: red component
 584  * @green: green component
 585  * @blue: blue component
 586  *
 587  * DESCRIPTION:
 588  * Reads red, green, and blue from color register @regnum.
 589  *
 590  * CALLED FROM:
 591  * rivafb_setcolreg()
 592  */
 593 static void riva_rclut(RIVA_HW_INST *chip,
 594                        unsigned char regnum, unsigned char *red,
 595                        unsigned char *green, unsigned char *blue)
 596 {
 597
 598         VGA_WR08(chip->PDIO, 0x3c8, regnum);
 599         *red = VGA_RD08(chip->PDIO, 0x3c9);
 600         *green = VGA_RD08(chip->PDIO, 0x3c9);
 601         *blue = VGA_RD08(chip->PDIO, 0x3c9);
 602 }
 603
 604 /**
 605  * riva_save_state - saves current chip state
 606  * @par: pointer to riva_par object containing info for current riva board
 607  * @regs: pointer to riva_regs object
 608  *
 609  * DESCRIPTION:
 610  * Saves current chip state to @regs.
 611  *
 612  * CALLED FROM:
 613  * rivafb_probe()
 614  */
 615 /* from GGI */
 616 static void riva_save_state(struct riva_par *par, struct riva_regs *regs)
 617 {
 618         int i;
 619
 620         par->riva.LockUnlock(&par->riva, 0);
 621
 622         par->riva.UnloadStateExt(&par->riva, &regs->ext);
 623
 624         regs->misc_output = MISCin(par);
 625
 626         for (i = 0; i < NUM_CRT_REGS; i++)
 627                 regs->crtc[i] = CRTCin(par, i);
 628
 629         for (i = 0; i < NUM_ATC_REGS; i++)
 630                 regs->attr[i] = ATTRin(par, i);
 631
 632         for (i = 0; i < NUM_GRC_REGS; i++)
 633                 regs->gra[i] = GRAin(par, i);
 634
 635         for (i = 0; i < NUM_SEQ_REGS; i++)
 636                 regs->seq[i] = SEQin(par, i);
 637 }
 638
 639 /**
 640  * riva_load_state - loads current chip state
 641  * @par: pointer to riva_par object containing info for current riva board
 642  * @regs: pointer to riva_regs object
 643  *
 644  * DESCRIPTION:
 645  * Loads chip state from @regs.
 646  *
 647  * CALLED FROM:
 648  * riva_load_video_mode()
 649  * rivafb_probe()
 650  * rivafb_remove()
 651  */
 652 /* from GGI */
 653 static void riva_load_state(struct riva_par *par, struct riva_regs *regs)
 654 {
 655         RIVA_HW_STATE *state = &regs->ext;
 656         int i;
 657
 658         CRTCout(par, 0x11, 0x00);
 659
 660         par->riva.LockUnlock(&par->riva, 0);
 661
 662         par->riva.LoadStateExt(&par->riva, state);
 663
 664         MISCout(par, regs->misc_output);
 665
 666         for (i = 0; i < NUM_CRT_REGS; i++) {
 667                 switch (i) {
 668                 case 0x19:
 669                 case 0x20 ... 0x40:
 670                         break;
 671                 default:
 672                         CRTCout(par, i, regs->crtc[i]);
 673                 }
 674         }
 675
 676         for (i = 0; i < NUM_ATC_REGS; i++)
 677                 ATTRout(par, i, regs->attr[i]);
 678
 679         for (i = 0; i < NUM_GRC_REGS; i++)
 680                 GRAout(par, i, regs->gra[i]);
 681
 682         for (i = 0; i < NUM_SEQ_REGS; i++)
 683                 SEQout(par, i, regs->seq[i]);
 684 }
 685
 686 /**
 687  * riva_load_video_mode - calculate timings
 688  * @info: pointer to fb_info object containing info for current riva board
 689  *
 690  * DESCRIPTION:
 691  * Calculate some timings and then send em off to riva_load_state().
 692  *
 693  * CALLED FROM:
 694  * rivafb_set_par()
 695  */
 696 static void riva_load_video_mode(struct fb_info *info)
 697 {
 698         int bpp, width, hDisplaySize, hDisplay, hStart,
 699             hEnd, hTotal, height, vDisplay, vStart, vEnd, vTotal, dotClock;
 700         int hBlankStart, hBlankEnd, vBlankStart, vBlankEnd;
 701         struct riva_par *par = (struct riva_par *) info->par;
 702         struct riva_regs newmode;
 703
 704         /* time to calculate */
 705         rivafb_blank(1, info);
 706
 707         bpp = info->var.bits_per_pixel;
 708         if (bpp == 16 && info->var.green.length == 5)
 709                 bpp = 15;
 710         width = info->var.xres_virtual;
 711         hDisplaySize = info->var.xres;
 712         hDisplay = (hDisplaySize / 8) - 1;
 713         hStart = (hDisplaySize + info->var.right_margin) / 8 - 1;
 714         hEnd = (hDisplaySize + info->var.right_margin +
 715                 info->var.hsync_len) / 8 - 1;
 716         hTotal = (hDisplaySize + info->var.right_margin +
 717                   info->var.hsync_len + info->var.left_margin) / 8 - 5;
 718         hBlankStart = hDisplay;
 719         hBlankEnd = hTotal + 4;
 720
 721         height = info->var.yres_virtual;
 722         vDisplay = info->var.yres - 1;
 723         vStart = info->var.yres + info->var.lower_margin - 1;
 724         vEnd = info->var.yres + info->var.lower_margin +
 725                info->var.vsync_len - 1;
 726         vTotal = info->var.yres + info->var.lower_margin +
 727                  info->var.vsync_len + info->var.upper_margin + 2;
 728         vBlankStart = vDisplay;
 729         vBlankEnd = vTotal + 1;
 730         dotClock = 1000000000 / info->var.pixclock;
 731
 732         memcpy(&newmode, &reg_template, sizeof(struct riva_regs));
 733
 734         if ((info->var.vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED)
 735                 vTotal |= 1;
 736
 737         if (par->FlatPanel) {
 738                 vStart = vTotal - 3;
 739                 vEnd = vTotal - 2;
 740                 vBlankStart = vStart;
 741                 hStart = hTotal - 3;
 742                 hEnd = hTotal - 2;
 743                 hBlankEnd = hTotal + 4;
 744         }
 745
 746         newmode.crtc[0x0] = Set8Bits (hTotal);
 747         newmode.crtc[0x1] = Set8Bits (hDisplay);
 748         newmode.crtc[0x2] = Set8Bits (hBlankStart);
 749         newmode.crtc[0x3] = SetBitField (hBlankEnd, 4: 0, 4:0) | SetBit (7);
 750         newmode.crtc[0x4] = Set8Bits (hStart);
 751         newmode.crtc[0x5] = SetBitField (hBlankEnd, 5: 5, 7:7)
 752                 | SetBitField (hEnd, 4: 0, 4:0);
 753         newmode.crtc[0x6] = SetBitField (vTotal, 7: 0, 7:0);
 754         newmode.crtc[0x7] = SetBitField (vTotal, 8: 8, 0:0)
 755                 | SetBitField (vDisplay, 8: 8, 1:1)
 756                 | SetBitField (vStart, 8: 8, 2:2)
 757                 | SetBitField (vBlankStart, 8: 8, 3:3)
 758                 | SetBit (4)
 759                 | SetBitField (vTotal, 9: 9, 5:5)
 760                 | SetBitField (vDisplay, 9: 9, 6:6)
 761                 | SetBitField (vStart, 9: 9, 7:7);
 762         newmode.crtc[0x9] = SetBitField (vBlankStart, 9: 9, 5:5)
 763                 | SetBit (6);
 764         newmode.crtc[0x10] = Set8Bits (vStart);
 765         newmode.crtc[0x11] = SetBitField (vEnd, 3: 0, 3:0)
 766                 | SetBit (5);
 767         newmode.crtc[0x12] = Set8Bits (vDisplay);
 768         newmode.crtc[0x13] = (width / 8) * ((bpp + 1) / 8);
 769         newmode.crtc[0x15] = Set8Bits (vBlankStart);
 770         newmode.crtc[0x16] = Set8Bits (vBlankEnd);
 771
 772         newmode.ext.screen = SetBitField(hBlankEnd,6:6,4:4)
 773                 | SetBitField(vBlankStart,10:10,3:3)
 774                 | SetBitField(vStart,10:10,2:2)
 775                 | SetBitField(vDisplay,10:10,1:1)
 776                 | SetBitField(vTotal,10:10,0:0);
 777         newmode.ext.horiz  = SetBitField(hTotal,8:8,0:0)
 778                 | SetBitField(hDisplay,8:8,1:1)
 779                 | SetBitField(hBlankStart,8:8,2:2)
 780                 | SetBitField(hStart,8:8,3:3);
 781         newmode.ext.extra  = SetBitField(vTotal,11:11,0:0)
 782                 | SetBitField(vDisplay,11:11,2:2)
 783                 | SetBitField(vStart,11:11,4:4)
 784                 | SetBitField(vBlankStart,11:11,6:6);
 785
 786         if ((info->var.vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
 787                 int tmp = (hTotal >> 1) & ~1;
 788                 newmode.ext.interlace = Set8Bits(tmp);
 789                 newmode.ext.horiz |= SetBitField(tmp, 8:8,4:4);
 790         } else
 791                 newmode.ext.interlace = 0xff; /* interlace off */
 792
 793         if (par->riva.Architecture >= NV_ARCH_10)
 794                 par->riva.CURSOR = (U032 *)(info->screen_base + par->riva.CursorStart);
 795
 796         if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
 797                 newmode.misc_output &= ~0x40;
 798         else
 799                 newmode.misc_output |= 0x40;
 800         if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
 801                 newmode.misc_output &= ~0x80;
 802         else
 803                 newmode.misc_output |= 0x80;
 804
 805         par->riva.CalcStateExt(&par->riva, &newmode.ext, bpp, width,
 806                                   hDisplaySize, height, dotClock);
 807
 808         newmode.ext.scale = par->riva.PRAMDAC[0x00000848/4] & 0xfff000ff;
 809         if (par->FlatPanel == 1) {
 810                 newmode.ext.pixel |= (1 << 7);
 811                 newmode.ext.scale |= (1 << 8);
 812         }
 813         if (par->SecondCRTC) {
 814                 newmode.ext.head  = par->riva.PCRTC0[0x00000860/4] & ~0x00001000;
 815                 newmode.ext.head2 = par->riva.PCRTC0[0x00002860/4] | 0x00001000;
 816                 newmode.ext.crtcOwner = 3;
 817                 newmode.ext.pllsel |= 0x20000800;
 818                 newmode.ext.vpll2 = newmode.ext.vpll;
 819         } else if (par->riva.twoHeads) {
 820                 newmode.ext.head  =  par->riva.PCRTC0[0x00000860/4] | 0x00001000;
 821                 newmode.ext.head2 =  par->riva.PCRTC0[0x00002860/4] & ~0x00001000;
 822                 newmode.ext.crtcOwner = 0;
 823                 newmode.ext.vpll2 = par->riva.PRAMDAC0[0x00000520/4];
 824         }
 825         if (par->FlatPanel == 1) {
 826                 newmode.ext.pixel |= (1 << 7);
 827                 newmode.ext.scale |= (1 << 8);
 828         }
 829         newmode.ext.cursorConfig = 0x02000100;
 830         par->current_state = newmode;
 831         riva_load_state(par, &par->current_state);
 832         par->riva.LockUnlock(&par->riva, 0); /* important for HW cursor */
 833         rivafb_blank(0, info);
 834 }
 835
 836 /**
 837  * rivafb_do_maximize -
 838  * @info: pointer to fb_info object containing info for current riva board
 839  * @var:
 840  * @nom:
 841  * @den:
 842  *
 843  * DESCRIPTION:
 844  * .
 845  *
 846  * RETURNS:
 847  * -EINVAL on failure, 0 on success
 848  *
 849  *
 850  * CALLED FROM:
 851  * rivafb_check_var()
 852  */
 853 static int rivafb_do_maximize(struct fb_info *info,
 854                               struct fb_var_screeninfo *var,
 855                               int nom, int den)
 856 {
 857         static struct {
 858                 int xres, yres;
 859         } modes[] = {
 860                 {1600, 1280},
 861                 {1280, 1024},
 862                 {1024, 768},
 863                 {800, 600},
 864                 {640, 480},
 865                 {-1, -1}
 866         };
 867         int i;
 868
 869         /* use highest possible virtual resolution */
 870         if (var->xres_virtual == -1 && var->yres_virtual == -1) {
 871                 printk(KERN_WARNING PFX
 872                        "using maximum available virtual resolution\n");
 873                 for (i = 0; modes[i].xres != -1; i++) {
 874                         if (modes[i].xres * nom / den * modes[i].yres <
 875                             info->fix.smem_len / 2)
 876                                 break;
 877                 }
 878                 if (modes[i].xres == -1) {
 879                         printk(KERN_ERR PFX
 880                                "could not find a virtual resolution that fits into video memory!!\n");
 881                         DPRINTK("EXIT - EINVAL error\n");
 882                         return -EINVAL;
 883                 }
 884                 var->xres_virtual = modes[i].xres;
 885                 var->yres_virtual = modes[i].yres;
 886
 887                 printk(KERN_INFO PFX
 888                        "virtual resolution set to maximum of %dx%d\n",
 889                        var->xres_virtual, var->yres_virtual);
 890         } else if (var->xres_virtual == -1) {
 891                 var->xres_virtual = (info->fix.smem_len * den /
 892                         (nom * var->yres_virtual * 2)) & ~15;
 893                 printk(KERN_WARNING PFX
 894                        "setting virtual X resolution to %d\n", var->xres_virtual);
 895         } else if (var->yres_virtual == -1) {
 896                 var->xres_virtual = (var->xres_virtual + 15) & ~15;
 897                 var->yres_virtual = info->fix.smem_len * den /
 898                         (nom * var->xres_virtual * 2);
 899                 printk(KERN_WARNING PFX
 900                        "setting virtual Y resolution to %d\n", var->yres_virtual);
 901         } else {
 902                 var->xres_virtual = (var->xres_virtual + 15) & ~15;
 903                 if (var->xres_virtual * nom / den * var->yres_virtual > info->fix.smem_len) {
 904                         printk(KERN_ERR PFX
 905                                "mode %dx%dx%d rejected...resolution too high to fit into video memory!\n",
 906                                var->xres, var->yres, var->bits_per_pixel);
 907                         DPRINTK("EXIT - EINVAL error\n");
 908                         return -EINVAL;
 909                 }
 910         }
 911
 912         if (var->xres_virtual * nom / den >= 8192) {
 913                 printk(KERN_WARNING PFX
 914                        "virtual X resolution (%d) is too high, lowering to %d\n",
 915                        var->xres_virtual, 8192 * den / nom - 16);
 916                 var->xres_virtual = 8192 * den / nom - 16;
 917         }
 918
 919         if (var->xres_virtual < var->xres) {
 920                 printk(KERN_ERR PFX
 921                        "virtual X resolution (%d) is smaller than real\n", var->xres_virtual);
 922                 return -EINVAL;
 923         }
 924
 925         if (var->yres_virtual < var->yres) {
 926                 printk(KERN_ERR PFX
 927                        "virtual Y resolution (%d) is smaller than real\n", var->yres_virtual);
 928                 return -EINVAL;
 929         }
 930         return 0;
 931 }
 932
 933 /* acceleration routines */
 934 inline void wait_for_idle(struct riva_par *par)
 935 {
 936         while (par->riva.Busy(&par->riva));
 937 }
 938
 939 /* set copy ROP, no mask */
 940 static void riva_setup_ROP(struct riva_par *par)
 941 {
 942         RIVA_FIFO_FREE(par->riva, Patt, 5);
 943         par->riva.Patt->Shape = 0;
 944         par->riva.Patt->Color0 = 0xffffffff;
 945         par->riva.Patt->Color1 = 0xffffffff;
 946         par->riva.Patt->Monochrome[0] = 0xffffffff;
 947         par->riva.Patt->Monochrome[1] = 0xffffffff;
 948
 949         RIVA_FIFO_FREE(par->riva, Rop, 1);
 950         par->riva.Rop->Rop3 = 0xCC;
 951 }
 952
 953 void riva_setup_accel(struct riva_par *par)
 954 {
 955         RIVA_FIFO_FREE(par->riva, Clip, 2);
 956         par->riva.Clip->TopLeft     = 0x0;
 957         par->riva.Clip->WidthHeight = 0x80008000;
 958         riva_setup_ROP(par);
 959         wait_for_idle(par);
 960 }
 961
 962 /**
 963  * riva_get_cmap_len - query current color map length
 964  * @var: standard kernel fb changeable data
 965  *
 966  * DESCRIPTION:
 967  * Get current color map length.
 968  *
 969  * RETURNS:
 970  * Length of color map
 971  *
 972  * CALLED FROM:
 973  * rivafb_setcolreg()
 974  */
 975 static int riva_get_cmap_len(const struct fb_var_screeninfo *var)
 976 {
 977         int rc = 256;           /* reasonable default */
 978
 979         switch (var->green.length) {
 980         case 8:
 981                 rc = 256;       /* 256 entries (2^8), 8 bpp and RGB8888 */
 982                 break;
 983         case 5:
 984                 rc = 32;        /* 32 entries (2^5), 16 bpp, RGB555 */
 985                 break;
 986         case 6:
 987                 rc = 64;        /* 64 entries (2^6), 16 bpp, RGB565 */
 988                 break;
 989         default:
 990                 /* should not occur */
 991                 break;
 992         }
 993         return rc;
 994 }
 995
 996 /* ------------------------------------------------------------------------- *
 997  *
 998  * framebuffer operations
 999  *
1000  * ------------------------------------------------------------------------- */
1001
1002 static int rivafb_open(struct fb_info *info, int user)
1003 {
1004         struct riva_par *par = (struct riva_par *) info->par;
1005         int cnt = atomic_read(&par->ref_count);
1006
1007         if (!cnt) {
1008                 memset(&par->state, 0, sizeof(struct vgastate));
1009                 par->state.flags = VGA_SAVE_MODE  | VGA_SAVE_FONTS;
1010                 /* save the DAC for Riva128 */
1011                 if (par->riva.Architecture == NV_ARCH_03)
1012                         par->state.flags |= VGA_SAVE_CMAP;
1013                 save_vga(&par->state);
1014
1015                 RivaGetConfig(&par->riva, par->Chipset);
1016                 /* vgaHWunlock() + riva unlock (0x7F) */
1017                 CRTCout(par, 0x11, 0xFF);
1018                 par->riva.LockUnlock(&par->riva, 0);
1019
1020                 riva_save_state(par, &par->initial_state);
1021         }
1022         atomic_inc(&par->ref_count);
1023         return 0;
1024 }
1025
1026 static int rivafb_release(struct fb_info *info, int user)
1027 {
1028         struct riva_par *par = (struct riva_par *) info->par;
1029         int cnt = atomic_read(&par->ref_count);
1030
1031         if (!cnt)
1032                 return -EINVAL;
1033         if (cnt == 1) {
1034                 par->riva.LockUnlock(&par->riva, 0);
1035                 par->riva.LoadStateExt(&par->riva, &par->initial_state.ext);
1036                 riva_load_state(par, &par->initial_state);
1037                 restore_vga(&par->state);
1038                 par->riva.LockUnlock(&par->riva, 1);
1039         }
1040         atomic_dec(&par->ref_count);
1041         return 0;
1042 }
1043
1044 static int rivafb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1045 {
1046         int nom, den;           /* translating from pixels->bytes */
1047
1048         switch (var->bits_per_pixel) {
1049         case 1 ... 8:
1050                 var->red.offset = var->green.offset = var->blue.offset = 0;
1051                 var->red.length = var->green.length = var->blue.length = 8;
1052                 var->bits_per_pixel = 8;
1053                 nom = den = 1;
1054                 break;
1055         case 9 ... 15:
1056                 var->green.length = 5;
1057                 /* fall through */
1058         case 16:
1059                 var->bits_per_pixel = 16;
1060                 if (var->green.length == 5) {
1061                         /* 0rrrrrgg gggbbbbb */
1062                         var->red.offset = 10;
1063                         var->green.offset = 5;
1064                         var->blue.offset = 0;
1065                         var->red.length = 5;
1066                         var->green.length = 5;
1067                         var->blue.length = 5;
1068                 } else {
1069                         /* rrrrrggg gggbbbbb */
1070                         var->red.offset = 11;
1071                         var->green.offset = 5;
1072                         var->blue.offset = 0;
1073                         var->red.length = 5;
1074                         var->green.length = 6;
1075                         var->blue.length = 5;
1076                 }
1077                 nom = 2;
1078                 den = 1;
1079                 break;
1080         case 17 ... 32:
1081                 var->red.length = var->green.length = var->blue.length = 8;
1082                 var->bits_per_pixel = 32;
1083                 var->red.offset = 16;
1084                 var->green.offset = 8;
1085                 var->blue.offset = 0;
1086                 nom = 4;
1087                 den = 1;
1088                 break;
1089         default:
1090                 printk(KERN_ERR PFX
1091                        "mode %dx%dx%d rejected...color depth not supported.\n",
1092                        var->xres, var->yres, var->bits_per_pixel);
1093                 DPRINTK("EXIT, returning -EINVAL\n");
1094                 return -EINVAL;
1095         }
1096
1097         if (rivafb_do_maximize(info, var, nom, den) < 0)
1098                 return -EINVAL;
1099
1100         if (var->xoffset < 0)
1101                 var->xoffset = 0;
1102         if (var->yoffset < 0)
1103                 var->yoffset = 0;
1104
1105         /* truncate xoffset and yoffset to maximum if too high */
1106         if (var->xoffset > var->xres_virtual - var->xres)
1107                 var->xoffset = var->xres_virtual - var->xres - 1;
1108
1109         if (var->yoffset > var->yres_virtual - var->yres)
1110                 var->yoffset = var->yres_virtual - var->yres - 1;
1111
1112         var->red.msb_right =
1113             var->green.msb_right =
1114             var->blue.msb_right =
1115             var->transp.offset = var->transp.length = var->transp.msb_right = 0;
1116         return 0;
1117 }
1118
1119 static int rivafb_set_par(struct fb_info *info)
1120 {
1121         struct riva_par *par = (struct riva_par *) info->par;
1122
1123         riva_load_video_mode(info);
1124         riva_setup_accel(par);
1125
1126         info->fix.line_length = (info->var.xres_virtual * (info->var.bits_per_pixel >> 3));
1127         info->fix.visual = (info->var.bits_per_pixel == 8) ?
1128                                 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_DIRECTCOLOR;
1129         return 0;
1130 }
1131
1132 /**
1133  * rivafb_pan_display
1134  * @var: standard kernel fb changeable data
1135  * @con: TODO
1136  * @info: pointer to fb_info object containing info for current riva board
1137  *
1138  * DESCRIPTION:
1139  * Pan (or wrap, depending on the `vmode' field) the display using the
1140  * `xoffset' and `yoffset' fields of the `var' structure.
1141  * If the values don't fit, return -EINVAL.
1142  *
1143  * This call looks only at xoffset, yoffset and the FB_VMODE_YWRAP flag
1144  */
1145 static int rivafb_pan_display(struct fb_var_screeninfo *var,
1146                               struct fb_info *info)
1147 {
1148         struct riva_par *par = (struct riva_par *)info->par;
1149         unsigned int base;
1150
1151         if (var->xoffset > (var->xres_virtual - var->xres))
1152                 return -EINVAL;
1153         if (var->yoffset > (var->yres_virtual - var->yres))
1154                 return -EINVAL;
1155
1156         if (var->vmode & FB_VMODE_YWRAP) {
1157                 if (var->yoffset < 0
1158                     || var->yoffset >= info->var.yres_virtual
1159                     || var->xoffset) return -EINVAL;
1160         } else {
1161                 if (var->xoffset + info->var.xres > info->var.xres_virtual ||
1162                     var->yoffset + info->var.yres > info->var.yres_virtual)
1163                         return -EINVAL;
1164         }
1165
1166         base = var->yoffset * info->fix.line_length + var->xoffset;
1167
1168         par->riva.SetStartAddress(&par->riva, base);
1169
1170         info->var.xoffset = var->xoffset;
1171         info->var.yoffset = var->yoffset;
1172
1173         if (var->vmode & FB_VMODE_YWRAP)
1174                 info->var.vmode |= FB_VMODE_YWRAP;
1175         else
1176                 info->var.vmode &= ~FB_VMODE_YWRAP;
1177         return 0;
1178 }
1179
1180 static int rivafb_blank(int blank, struct fb_info *info)
1181 {
1182         struct riva_par *par= (struct riva_par *)info->par;
1183         unsigned char tmp, vesa;
1184
1185         tmp = SEQin(par, 0x01) & ~0x20; /* screen on/off */
1186         vesa = CRTCin(par, 0x1a) & ~0xc0;       /* sync on/off */
1187
1188         if (blank) {
1189                 tmp |= 0x20;
1190                 switch (blank - 1) {
1191                 case VESA_NO_BLANKING:
1192                         break;
1193                 case VESA_VSYNC_SUSPEND:
1194                         vesa |= 0x80;
1195                         break;
1196                 case VESA_HSYNC_SUSPEND:
1197                         vesa |= 0x40;
1198                         break;
1199                 case VESA_POWERDOWN:
1200                         vesa |= 0xc0;
1201                         break;
1202                 }
1203         }
1204         SEQout(par, 0x01, tmp);
1205         CRTCout(par, 0x1a, vesa);
1206         return 0;
1207 }
1208
1209 /**
1210  * rivafb_setcolreg
1211  * @regno: register index
1212  * @red: red component
1213  * @green: green component
1214  * @blue: blue component
1215  * @transp: transparency
1216  * @info: pointer to fb_info object containing info for current riva board
1217  *
1218  * DESCRIPTION:
1219  * Set a single color register. The values supplied have a 16 bit
1220  * magnitude.
1221  *
1222  * RETURNS:
1223  * Return != 0 for invalid regno.
1224  *
1225  * CALLED FROM:
1226  * fbcmap.c:fb_set_cmap()
1227  */
1228 static int rivafb_setcolreg(unsigned regno, unsigned red, unsigned green,
1229                           unsigned blue, unsigned transp,
1230                           struct fb_info *info)
1231 {
1232         struct riva_par *par = (struct riva_par *)info->par;
1233         RIVA_HW_INST *chip = &par->riva;
1234         int i;
1235
1236         if (regno >= riva_get_cmap_len(&info->var))
1237                 return -EINVAL;
1238
1239         if (info->var.grayscale) {
1240                 /* gray = 0.30*R + 0.59*G + 0.11*B */
1241                 red = green = blue =
1242                     (red * 77 + green * 151 + blue * 28) >> 8;
1243         }
1244
1245         switch (info->var.bits_per_pixel) {
1246         case 8:
1247                 /* "transparent" stuff is completely ignored. */
1248                 riva_wclut(chip, regno, red >> 8, green >> 8, blue >> 8);
1249                 break;
1250         case 16:
1251                 if (info->var.green.length == 5) {
1252                         if (regno < 16) {
1253                                 /* 0rrrrrgg gggbbbbb */
1254                                 ((u32 *)info->pseudo_palette)[regno] =
1255                                         ((red & 0xf800) >> 1) |
1256                                         ((green & 0xf800) >> 6) |
1257                                         ((blue & 0xf800) >> 11);
1258                         }
1259                         for (i = 0; i < 8; i++)
1260                                 riva_wclut(chip, regno*8+i, red >> 8,
1261                                            green >> 8, blue >> 8);
1262                 } else {
1263                         u8 r, g, b;
1264
1265                         if (regno < 16) {
1266                                 /* rrrrrggg gggbbbbb */
1267                                 ((u32 *)info->pseudo_palette)[regno] =
1268                                         ((red & 0xf800) >> 0) |
1269                                         ((green & 0xf800) >> 5) |
1270                                         ((blue & 0xf800) >> 11);
1271                         }
1272                         if (regno < 32) {
1273                                 for (i = 0; i < 8; i++) {
1274                                         riva_wclut(chip, regno*8+i, red >> 8,
1275                                                    green >> 8, blue >> 8);
1276                                 }
1277                         }
1278                         for (i = 0; i < 4; i++) {
1279                                 riva_rclut(chip, regno*2+i, &r, &g, &b);
1280                                 riva_wclut(chip, regno*4+i, r, green >> 8, b);
1281                         }
1282                 }
1283                 break;
1284         case 32:
1285                 if (regno < 16) {
1286                         ((u32 *)info->pseudo_palette)[regno] =
1287                                 ((red & 0xff00) << 8) |
1288                                 ((green & 0xff00)) | ((blue & 0xff00) >> 8);
1289
1290                 }
1291                 riva_wclut(chip, regno, red >> 8, green >> 8, blue >> 8);
1292                 break;
1293         default:
1294                 /* do nothing */
1295                 break;
1296         }
1297         return 0;
1298 }
1299
1300 /**
1301  * rivafb_fillrect - hardware accelerated color fill function
1302  * @info: pointer to fb_info structure
1303  * @rect: pointer to fb_fillrect structure
1304  *
1305  * DESCRIPTION:
1306  * This function fills up a region of framebuffer memory with a solid
1307  * color with a choice of two different ROP's, copy or invert.
1308  *
1309  * CALLED FROM:
1310  * framebuffer hook
1311  */
1312 static void rivafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
1313 {
1314         struct riva_par *par = (struct riva_par *) info->par;
1315         u_int color, rop = 0;
1316
1317         if (info->var.bits_per_pixel == 8)
1318                 color = rect->color;
1319         else
1320                 color = ((u32 *)info->pseudo_palette)[rect->color];
1321
1322         switch (rect->rop) {
1323         case ROP_XOR:
1324                 rop = 0x66;
1325                 break;
1326         case ROP_COPY:
1327         default:
1328                 rop = 0xCC;
1329                 break;
1330         }
1331
1332         RIVA_FIFO_FREE(par->riva, Rop, 1);
1333         par->riva.Rop->Rop3 = rop;
1334
1335         RIVA_FIFO_FREE(par->riva, Bitmap, 1);
1336         par->riva.Bitmap->Color1A = color;
1337
1338         RIVA_FIFO_FREE(par->riva, Bitmap, 2);
1339         par->riva.Bitmap->UnclippedRectangle[0].TopLeft =
1340                         (rect->dx << 16) | rect->dy;
1341         par->riva.Bitmap->UnclippedRectangle[0].WidthHeight =
1342                         (rect->width << 16) | rect->height;
1343         RIVA_FIFO_FREE(par->riva, Rop, 1);
1344         par->riva.Rop->Rop3 = 0xCC;     // back to COPY
1345 }
1346
1347 /**
1348  * rivafb_copyarea - hardware accelerated blit function
1349  * @info: pointer to fb_info structure
1350  * @region: pointer to fb_copyarea structure
1351  *
1352  * DESCRIPTION:
1353  * This copies an area of pixels from one location to another
1354  *
1355  * CALLED FROM:
1356  * framebuffer hook
1357  */
1358 static void rivafb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
1359 {
1360         struct riva_par *par = (struct riva_par *) info->par;
1361
1362         RIVA_FIFO_FREE(par->riva, Blt, 3);
1363         par->riva.Blt->TopLeftSrc  = (region->sy << 16) | region->sx;
1364         par->riva.Blt->TopLeftDst  = (region->dy << 16) | region->dx;
1365         par->riva.Blt->WidthHeight = (region->height << 16) | region->width;
1366         wait_for_idle(par);
1367 }
1368
1369 static inline void convert_bgcolor_16(u32 *col)
1370 {
1371         *col = ((*col & 0x00007C00) << 9)
1372                 | ((*col & 0x000003E0) << 6)
1373                 | ((*col & 0x0000001F) << 3)
1374                 |          0xFF000000;
1375 }
1376
1377 /**
1378  * rivafb_imageblit: hardware accelerated color expand function
1379  * @info: pointer to fb_info structure
1380  * @image: pointer to fb_image structure
1381  *
1382  * DESCRIPTION:
1383  * If the source is a monochrome bitmap, the function fills up a a region
1384  * of framebuffer memory with pixels whose color is determined by the bit
1385  * setting of the bitmap, 1 - foreground, 0 - background.
1386  *
1387  * If the source is not a monochrome bitmap, color expansion is not done.
1388  * In this case, it is channeled to a software function.
1389  *
1390  * CALLED FROM:
1391  * framebuffer hook
1392  */
1393 static void rivafb_imageblit(struct fb_info *info,
1394                              const struct fb_image *image)
1395 {
1396         struct riva_par *par = (struct riva_par *) info->par;
1397         u32 fgx = 0, bgx = 0, width, tmp;
1398         u8 *cdat = (u8 *) image->data;
1399         volatile u32 *d;
1400         int i, size;
1401
1402         if (image->depth != 1) {
1403                 cfb_imageblit(info, image);
1404                 return;
1405         }
1406
1407         switch (info->var.bits_per_pixel) {
1408         case 8:
1409                 fgx = image->fg_color;
1410                 bgx = image->bg_color;
1411                 break;
1412         case 16:
1413                 fgx = ((u32 *)info->pseudo_palette)[image->fg_color];
1414                 bgx = ((u32 *)info->pseudo_palette)[image->bg_color];
1415                 if (info->var.green.length == 6)
1416                         convert_bgcolor_16(&bgx);
1417                 break;
1418         case 32:
1419                 fgx = ((u32 *)info->pseudo_palette)[image->fg_color];
1420                 bgx = ((u32 *)info->pseudo_palette)[image->bg_color];
1421                 break;
1422         }
1423
1424         RIVA_FIFO_FREE(par->riva, Bitmap, 7);
1425         par->riva.Bitmap->ClipE.TopLeft     =
1426                 (image->dy << 16) | (image->dx & 0xFFFF);
1427         par->riva.Bitmap->ClipE.BottomRight =
1428                 (((image->dy + image->height) << 16) |
1429                  ((image->dx + image->width) & 0xffff));
1430         par->riva.Bitmap->Color0E           = bgx;
1431         par->riva.Bitmap->Color1E           = fgx;
1432         par->riva.Bitmap->WidthHeightInE    =
1433                 (image->height << 16) | ((image->width + 31) & ~31);
1434         par->riva.Bitmap->WidthHeightOutE   =
1435                 (image->height << 16) | ((image->width + 31) & ~31);
1436         par->riva.Bitmap->PointE            =
1437                 (image->dy << 16) | (image->dx & 0xFFFF);
1438
1439         d = &par->riva.Bitmap->MonochromeData01E;
1440
1441         width = (image->width + 31)/32;
1442         size = width * image->height;
1443         while (size >= 16) {
1444                 RIVA_FIFO_FREE(par->riva, Bitmap, 16);
1445                 for (i = 0; i < 16; i++) {
1446                         tmp = *((u32 *)cdat);
1447                         cdat = (u8 *)((u32 *)cdat + 1);
1448                         reverse_order(&tmp);
1449                         d[i] = tmp;
1450                 }
1451                 size -= 16;
1452         }
1453         if (size) {
1454                 RIVA_FIFO_FREE(par->riva, Bitmap, size);
1455                 for (i = 0; i < size; i++) {
1456                         tmp = *((u32 *) cdat);
1457                         cdat = (u8 *)((u32 *)cdat + 1);
1458                         reverse_order(&tmp);
1459                         d[i] = tmp;
1460                 }
1461         }
1462 }
1463
1464 /**
1465  * rivafb_cursor - hardware cursor function
1466  * @info: pointer to info structure
1467  * @cursor: pointer to fbcursor structure
1468  *
1469  * DESCRIPTION:
1470  * A cursor function that supports displaying a cursor image via hardware.
1471  * Within the kernel, copy and invert rops are supported.  If exported
1472  * to user space, only the copy rop will be supported.
1473  *
1474  * CALLED FROM
1475  * framebuffer hook
1476  */
1477 static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
1478 {
1479         struct riva_par *par = (struct riva_par *) info->par;
1480         u8 data[MAX_CURS * MAX_CURS/8];
1481         u8 mask[MAX_CURS * MAX_CURS/8];
1482         u16 fg, bg;
1483         int i;
1484
1485         par->riva.ShowHideCursor(&par->riva, 0);
1486
1487         if (cursor->set & FB_CUR_SETPOS) {
1488                 u32 xx, yy, temp;
1489
1490                 info->cursor.image.dx = cursor->image.dx;
1491                 info->cursor.image.dy = cursor->image.dy;
1492                 yy = cursor->image.dy - info->var.yoffset;
1493                 xx = cursor->image.dx - info->var.xoffset;
1494                 temp = xx & 0xFFFF;
1495                 temp |= yy << 16;
1496
1497                 par->riva.PRAMDAC[0x0000300/4] = temp;
1498         }
1499
1500         if (cursor->set & FB_CUR_SETSIZE) {
1501                 info->cursor.image.height = cursor->image.height;
1502                 info->cursor.image.width = cursor->image.width;
1503                 memset_io(par->riva.CURSOR, 0, MAX_CURS * MAX_CURS * 2);
1504         }
1505
1506         if (cursor->set & FB_CUR_SETCMAP) {
1507                 info->cursor.image.bg_color = cursor->image.bg_color;
1508                 info->cursor.image.fg_color = cursor->image.fg_color;
1509         }
1510
1511         if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETCMAP)) {
1512                 u32 bg_idx = info->cursor.image.bg_color;
1513                 u32 fg_idx = info->cursor.image.fg_color;
1514                 u32 s_pitch = (info->cursor.image.width+7) >> 3;
1515                 u32 d_pitch = MAX_CURS/8;
1516                 u8 *dat = (u8 *) cursor->image.data;
1517                 u8 *msk = (u8 *) info->cursor.mask;
1518                 u8 src[64];
1519
1520                 switch (info->cursor.rop) {
1521                 case ROP_XOR:
1522                         for (i = 0; i < s_pitch * info->cursor.image.height; i++)
1523                                         src[i] = dat[i] ^ msk[i];
1524                         break;
1525                 case ROP_COPY:
1526                 default:
1527                         for (i = 0; i < s_pitch * info->cursor.image.height; i++)
1528
1529                                         src[i] = dat[i] & msk[i];
1530                         break;
1531                 }
1532
1533                 fb_move_buf_aligned(info, &info->sprite, data, d_pitch, src, s_pitch, info->cursor.image.height);
1534
1535                 fb_move_buf_aligned(info, &info->sprite, mask, d_pitch, msk, s_pitch, info->cursor.image.height);
1536
1537                 bg = ((info->cmap.red[bg_idx] & 0xf8) << 7) |
1538                      ((info->cmap.green[bg_idx] & 0xf8) << 2) |
1539                      ((info->cmap.blue[bg_idx] & 0xf8) >> 3);
1540
1541                 fg = ((info->cmap.red[fg_idx] & 0xf8) << 7) |
1542                      ((info->cmap.green[fg_idx] & 0xf8) << 2) |
1543                      ((info->cmap.blue[fg_idx] & 0xf8) >> 3);
1544
1545                 par->riva.LockUnlock(&par->riva, 0);
1546
1547                 rivafb_load_cursor_image(par, data, mask, bg, fg,
1548                                          info->cursor.image.width,
1549                                          info->cursor.image.height);
1550         }
1551         if (info->cursor.enable)
1552                 par->riva.ShowHideCursor(&par->riva, 1);
1553         return 0;
1554 }
1555
1556 static int rivafb_sync(struct fb_info *info)
1557 {
1558         struct riva_par *par = (struct riva_par *)info->par;
1559
1560         wait_for_idle(par);
1561         return 0;
1562 }
1563
1564 /* ------------------------------------------------------------------------- *
1565  *
1566  * initialization helper functions
1567  *
1568  * ------------------------------------------------------------------------- */
1569
1570 /* kernel interface */
1571 static struct fb_ops riva_fb_ops = {
1572         .owner          = THIS_MODULE,
1573         .fb_open        = rivafb_open,
1574         .fb_release     = rivafb_release,
1575         .fb_check_var   = rivafb_check_var,
1576         .fb_set_par     = rivafb_set_par,
1577         .fb_setcolreg   = rivafb_setcolreg,
1578         .fb_pan_display = rivafb_pan_display,
1579         .fb_blank       = rivafb_blank,
1580         .fb_fillrect    = rivafb_fillrect,
1581         .fb_copyarea    = rivafb_copyarea,
1582         .fb_imageblit   = rivafb_imageblit,
1583         .fb_cursor      = rivafb_cursor,
1584         .fb_sync        = rivafb_sync,
1585 };
1586
1587 static int __devinit riva_set_fbinfo(struct fb_info *info)
1588 {
1589         struct riva_par *par = (struct riva_par *) info->par;
1590         unsigned int cmap_len;
1591
1592         info->flags = FBINFO_FLAG_DEFAULT;
1593         info->var = rivafb_default_var;
1594         info->fix = rivafb_fix;
1595         info->fbops = &riva_fb_ops;
1596         info->pseudo_palette = pseudo_palette;
1597
1598 #ifndef MODULE
1599         if (mode_option)
1600                 fb_find_mode(&info->var, info, mode_option,
1601                              NULL, 0, NULL, 8);
1602 #endif
1603         if (par->use_default_var)
1604                 /* We will use the modified default var */
1605                 info->var = rivafb_default_var;
1606
1607         cmap_len = riva_get_cmap_len(&info->var);
1608         fb_alloc_cmap(&info->cmap, cmap_len, 0);
1609
1610         info->pixmap.size = 64 * 1024;
1611         info->pixmap.buf_align = 4;
1612         info->pixmap.scan_align = 4;
1613         info->pixmap.flags = FB_PIXMAP_SYSTEM;
1614         return 0;
1615 }
1616
1617 #ifdef CONFIG_PPC_OF
1618 static int riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd)
1619 {
1620         struct riva_par *par = (struct riva_par *) info->par;
1621         struct device_node *dp;
1622         unsigned char *pedid = NULL;
1623         unsigned char *disptype = NULL;
1624         static char *propnames[] = {
1625                 "DFP,EDID", "LCD,EDID", "EDID", "EDID1", "EDID,B", "EDID,A", NULL };
1626         int i;
1627
1628         dp = pci_device_to_OF_node(pd);
1629         for (; dp != NULL; dp = dp->child) {
1630                 disptype = (unsigned char *)get_property(dp, "display-type", NULL);
1631                 if (disptype == NULL)
1632                         continue;
1633                 if (strncmp(disptype, "LCD", 3) != 0)
1634                         continue;
1635                 for (i = 0; propnames[i] != NULL; ++i) {
1636                         pedid = (unsigned char *)
1637                                 get_property(dp, propnames[i], NULL);
1638                         if (pedid != NULL) {
1639                 par->EDID = pedid;
1640                 return 1;
1641                         }
1642                 }
1643         }
1644                 return 0;
1645 }
1646 #endif /* CONFIG_PPC_OF */
1647
1648 static int riva_dfp_parse_EDID(struct riva_par *par)
1649 {
1650         unsigned char *block = par->EDID;
1651
1652         if (!block)
1653                 return 0;
1654
1655         /* jump to detailed timing block section */
1656         block += 54;
1657
1658         par->clock = (block[0] + (block[1] << 8));
1659         par->panel_xres = (block[2] + ((block[4] & 0xf0) << 4));
1660         par->hblank = (block[3] + ((block[4] & 0x0f) << 8));
1661         par->panel_yres = (block[5] + ((block[7] & 0xf0) << 4));
1662         par->vblank = (block[6] + ((block[7] & 0x0f) << 8));
1663         par->hOver_plus = (block[8] + ((block[11] & 0xc0) << 2));
1664         par->hSync_width = (block[9] + ((block[11] & 0x30) << 4));
1665         par->vOver_plus = ((block[10] >> 4) + ((block[11] & 0x0c) << 2));
1666         par->vSync_width = ((block[10] & 0x0f) + ((block[11] & 0x03) << 4));
1667         par->interlaced = ((block[17] & 0x80) >> 7);
1668         par->synct = ((block[17] & 0x18) >> 3);
1669         par->misc = ((block[17] & 0x06) >> 1);
1670         par->hAct_high = par->vAct_high = 0;
1671         if (par->synct == 3) {
1672                 if (par->misc & 2)
1673                         par->hAct_high = 1;
1674                 if (par->misc & 1)
1675                         par->vAct_high = 1;
1676         }
1677
1678         printk(KERN_INFO PFX
1679                         "detected DFP panel size from EDID: %dx%d\n",
1680                         par->panel_xres, par->panel_yres);
1681         par->got_dfpinfo = 1;
1682         return 1;
1683 }
1684
1685 static void riva_update_default_var(struct fb_info *info)
1686 {
1687         struct fb_var_screeninfo *var = &rivafb_default_var;
1688         struct riva_par *par = (struct riva_par *) info->par;
1689
1690         var->xres = par->panel_xres;
1691         var->yres = par->panel_yres;
1692         var->xres_virtual = par->panel_xres;
1693         var->yres_virtual = par->panel_yres;
1694         var->xoffset = var->yoffset = 0;
1695         var->bits_per_pixel = 8;
1696         var->pixclock = 100000000 / par->clock;
1697         var->left_margin = (par->hblank - par->hOver_plus - par->hSync_width);
1698         var->right_margin = par->hOver_plus;
1699         var->upper_margin = (par->vblank - par->vOver_plus - par->vSync_width);
1700         var->lower_margin = par->vOver_plus;
1701         var->hsync_len = par->hSync_width;
1702         var->vsync_len = par->vSync_width;
1703         var->sync = 0;
1704
1705         if (par->synct == 3) {
1706                 if (par->hAct_high)
1707                         var->sync |= FB_SYNC_HOR_HIGH_ACT;
1708                 if (par->vAct_high)
1709                         var->sync |= FB_SYNC_VERT_HIGH_ACT;
1710         }
1711
1712         var->vmode = 0;
1713         if (par->interlaced)
1714                 var->vmode |= FB_VMODE_INTERLACED;
1715
1716         var->accel_flags |= FB_ACCELF_TEXT;
1717
1718         par->use_default_var = 1;
1719 }
1720
1721
1722 static void riva_get_EDID(struct fb_info *info, struct pci_dev *pdev)
1723 {
1724 #ifdef CONFIG_PPC_OF
1725         if (!riva_get_EDID_OF(info, pdev))
1726                 printk("rivafb: could not retrieve EDID from OF\n");
1727 #else
1728         /* XXX use other methods later */
1729 #endif
1730 }
1731
1732
1733 static void riva_get_dfpinfo(struct fb_info *info)
1734 {
1735         struct riva_par *par = (struct riva_par *) info->par;
1736
1737         if (riva_dfp_parse_EDID(par))
1738                 riva_update_default_var(info);
1739
1740         /* if user specified flatpanel, we respect that */
1741         if (par->got_dfpinfo == 1)
1742                 par->FlatPanel = 1;
1743 }
1744
1745 /* ------------------------------------------------------------------------- *
1746  *
1747  * PCI bus
1748  *
1749  * ------------------------------------------------------------------------- */
1750
1751 static int __devinit rivafb_probe(struct pci_dev *pd,
1752                                 const struct pci_device_id *ent)
1753 {
1754         struct riva_chip_info *rci = &riva_chip_info[ent->driver_data];
1755         struct riva_par *default_par;
1756         struct fb_info *info;
1757
1758         assert(pd != NULL);
1759         assert(rci != NULL);
1760
1761         info = kmalloc(sizeof(struct fb_info), GFP_KERNEL);
1762         if (!info)
1763                 goto err_out;
1764
1765         default_par = kmalloc(sizeof(struct riva_par), GFP_KERNEL);
1766         if (!default_par)
1767                 goto err_out_kfree;
1768
1769         memset(info, 0, sizeof(struct fb_info));
1770         memset(default_par, 0, sizeof(struct riva_par));
1771
1772         info->pixmap.addr = kmalloc(64 * 1024, GFP_KERNEL);
1773         if (info->pixmap.addr == NULL)
1774                 goto err_out_kfree1;
1775         memset(info->pixmap.addr, 0, 64 * 1024);
1776
1777         strcat(rivafb_fix.id, rci->name);
1778         default_par->riva.Architecture = rci->arch_rev;
1779
1780         default_par->Chipset = (pd->vendor << 16) | pd->device;
1781         printk(KERN_INFO PFX "nVidia device/chipset %X\n",default_par->Chipset);
1782
1783         default_par->FlatPanel = flatpanel;
1784         if (flatpanel == 1)
1785                 printk(KERN_INFO PFX "flatpanel support enabled\n");
1786         default_par->forceCRTC = forceCRTC;
1787
1788         rivafb_fix.mmio_len = pci_resource_len(pd, 0);
1789         rivafb_fix.smem_len = pci_resource_len(pd, 1);
1790
1791         {
1792                 /* enable IO and mem if not already done */
1793                 unsigned short cmd;
1794
1795                 pci_read_config_word(pd, PCI_COMMAND, &cmd);
1796                 cmd |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
1797                 pci_write_config_word(pd, PCI_COMMAND, cmd);
1798         }
1799
1800         rivafb_fix.mmio_start = pci_resource_start(pd, 0);
1801         rivafb_fix.smem_start = pci_resource_start(pd, 1);
1802
1803         if (!request_mem_region(rivafb_fix.mmio_start,
1804                                 rivafb_fix.mmio_len, "rivafb")) {
1805                 printk(KERN_ERR PFX "cannot reserve MMIO region\n");
1806                 goto err_out_kfree2;
1807         }
1808
1809         default_par->ctrl_base = ioremap(rivafb_fix.mmio_start,
1810                                          rivafb_fix.mmio_len);
1811         if (!default_par->ctrl_base) {
1812                 printk(KERN_ERR PFX "cannot ioremap MMIO base\n");
1813                 goto err_out_free_base0;
1814         }
1815
1816         info->par = default_par;
1817
1818         riva_get_EDID(info, pd);
1819
1820         riva_get_dfpinfo(info);
1821
1822         switch (default_par->riva.Architecture) {
1823         case NV_ARCH_03:
1824                 /* Riva128's PRAMIN is in the "framebuffer" space
1825                  * Since these cards were never made with more than 8 megabytes
1826                  * we can safely allocate this separately.
1827                  */
1828                 if (!request_mem_region(rivafb_fix.smem_start + 0x00C00000,
1829                                          0x00008000, "rivafb")) {
1830                         printk(KERN_ERR PFX "cannot reserve PRAMIN region\n");
1831                         goto err_out_iounmap_ctrl;
1832                 }
1833                 default_par->riva.PRAMIN = ioremap(rivafb_fix.smem_start + 0x00C00000, 0x00008000);
1834                 if (!default_par->riva.PRAMIN) {
1835                         printk(KERN_ERR PFX "cannot ioremap PRAMIN region\n");
1836                         goto err_out_free_nv3_pramin;
1837                 }
1838                 rivafb_fix.accel = FB_ACCEL_NV3;
1839                 break;
1840         case NV_ARCH_04:
1841         case NV_ARCH_10:
1842         case NV_ARCH_20:
1843                 default_par->riva.PCRTC0 = (unsigned *)(default_par->ctrl_base + 0x00600000);
1844                 default_par->riva.PRAMIN = (unsigned *)(default_par->ctrl_base + 0x00710000);
1845                 rivafb_fix.accel = FB_ACCEL_NV4;
1846                 break;
1847         }
1848
1849         riva_common_setup(default_par);
1850
1851         if (default_par->riva.Architecture == NV_ARCH_03) {
1852                 default_par->riva.PCRTC = default_par->riva.PCRTC0 = default_par->riva.PGRAPH;
1853         }
1854
1855         rivafb_fix.smem_len = riva_get_memlen(default_par) * 1024;
1856         default_par->dclk_max = riva_get_maxdclk(default_par) * 1000;
1857
1858         if (!request_mem_region(rivafb_fix.smem_start,
1859                                 rivafb_fix.smem_len, "rivafb")) {
1860                 printk(KERN_ERR PFX "cannot reserve FB region\n");
1861                 goto err_out_iounmap_nv3_pramin;
1862         }
1863
1864         info->screen_base = ioremap(rivafb_fix.smem_start,
1865                                     rivafb_fix.smem_len);
1866         if (!info->screen_base) {
1867                 printk(KERN_ERR PFX "cannot ioremap FB base\n");
1868                 goto err_out_free_base1;
1869         }
1870
1871 #ifdef CONFIG_MTRR
1872         if (!nomtrr) {
1873                 default_par->mtrr.vram = mtrr_add(rivafb_fix.smem_start,
1874                                                   rivafb_fix.smem_len,
1875                                                   MTRR_TYPE_WRCOMB, 1);
1876                 if (default_par->mtrr.vram < 0) {
1877                         printk(KERN_ERR PFX "unable to setup MTRR\n");
1878                 } else {
1879                         default_par->mtrr.vram_valid = 1;
1880                         /* let there be speed */
1881                         printk(KERN_INFO PFX "RIVA MTRR set to ON\n");
1882                 }
1883         }
1884 #endif /* CONFIG_MTRR */
1885
1886         if (riva_set_fbinfo(info) < 0) {
1887                 printk(KERN_ERR PFX "error setting initial video mode\n");
1888                 goto err_out_iounmap_fb;
1889         }
1890
1891         if (register_framebuffer(info) < 0) {
1892                 printk(KERN_ERR PFX
1893                         "error registering riva framebuffer\n");
1894                 goto err_out_iounmap_fb;
1895         }
1896
1897         pci_set_drvdata(pd, info);
1898
1899         printk(KERN_INFO PFX
1900                 "PCI nVidia NV%x framebuffer ver %s (%s, %dMB @ 0x%lX)\n",
1901                 default_par->riva.Architecture,
1902                 RIVAFB_VERSION,
1903                 info->fix.id,
1904                 info->fix.smem_len / (1024 * 1024),
1905                 info->fix.smem_start);
1906         return 0;
1907
1908 err_out_iounmap_fb:
1909         iounmap(info->screen_base);
1910 err_out_free_base1:
1911         release_mem_region(rivafb_fix.smem_start, rivafb_fix.smem_len);
1912 err_out_iounmap_nv3_pramin:
1913         if (default_par->riva.Architecture == NV_ARCH_03)
1914                 iounmap((caddr_t)default_par->riva.PRAMIN);
1915 err_out_free_nv3_pramin:
1916         if (default_par->riva.Architecture == NV_ARCH_03)
1917                 release_mem_region(rivafb_fix.smem_start + 0x00C00000, 0x00008000);
1918 err_out_iounmap_ctrl:
1919         iounmap(default_par->ctrl_base);
1920 err_out_free_base0:
1921         release_mem_region(rivafb_fix.mmio_start, rivafb_fix.mmio_len);
1922 err_out_kfree2:
1923         kfree(info->pixmap.addr);
1924 err_out_kfree1:
1925         kfree(default_par);
1926 err_out_kfree:
1927         kfree(info);
1928 err_out:
1929         return -ENODEV;
1930 }
1931
1932 static void __exit rivafb_remove(struct pci_dev *pd)
1933 {
1934         struct fb_info *info = pci_get_drvdata(pd);
1935         struct riva_par *par = (struct riva_par *) info->par;
1936
1937         if (!info)
1938                 return;
1939
1940         unregister_framebuffer(info);
1941 #ifdef CONFIG_MTRR
1942         if (par->mtrr.vram_valid)
1943                 mtrr_del(par->mtrr.vram, info->fix.smem_start,
1944                          info->fix.smem_len);
1945 #endif /* CONFIG_MTRR */
1946
1947         iounmap(par->ctrl_base);
1948         iounmap(info->screen_base);
1949
1950         release_mem_region(info->fix.mmio_start,
1951                            info->fix.mmio_len);
1952         release_mem_region(info->fix.smem_start,
1953                            info->fix.smem_len);
1954
1955         if (par->riva.Architecture == NV_ARCH_03) {
1956                 iounmap((caddr_t)par->riva.PRAMIN);
1957                 release_mem_region(info->fix.smem_start + 0x00C00000, 0x00008000);
1958         }
1959         kfree(info->pixmap.addr);
1960         kfree(par);
1961         kfree(info);
1962         pci_set_drvdata(pd, NULL);
1963 }
1964
1965 /* ------------------------------------------------------------------------- *
1966  *
1967  * initialization
1968  *
1969  * ------------------------------------------------------------------------- */
1970
1971 #ifndef MODULE
1972 int __init rivafb_setup(char *options)
1973 {
1974         char *this_opt;
1975
1976         if (!options || !*options)
1977                 return 0;
1978
1979         while ((this_opt = strsep(&options, ",")) != NULL) {
1980                 if (!strncmp(this_opt, "forceCRTC", 9)) {
1981                         char *p;
1982
1983                         p = this_opt + 9;
1984                         if (!*p || !*(++p)) continue;
1985                         forceCRTC = *p - '0';
1986                         if (forceCRTC < 0 || forceCRTC > 1)
1987                                 forceCRTC = -1;
1988                 } else if (!strncmp(this_opt, "flatpanel", 9)) {
1989                         flatpanel = 1;
1990 #ifdef CONFIG_MTRR
1991                 } else if (!strncmp(this_opt, "nomtrr", 6)) {
1992                         nomtrr = 1;
1993 #endif
1994                 } else
1995                         mode_option = this_opt;
1996         }
1997         return 0;
1998 }
1999 #endif /* !MODULE */
2000
2001 static struct pci_driver rivafb_driver = {
2002         .name           = "rivafb",
2003         .id_table       = rivafb_pci_tbl,
2004         .probe          = rivafb_probe,
2005         .remove         = __exit_p(rivafb_remove),
2006 };
2007
2008
2009
2010 /* ------------------------------------------------------------------------- *
2011  *
2012  * modularization
2013  *
2014  * ------------------------------------------------------------------------- */
2015
2016 int __init rivafb_init(void)
2017 {
2018         if (pci_register_driver(&rivafb_driver) > 0)
2019                 return 0;
2020         pci_unregister_driver(&rivafb_driver);
2021         return -ENODEV;
2022 }
2023
2024
2025 #ifdef MODULE
2026 static void __exit rivafb_exit(void)
2027 {
2028         pci_unregister_driver(&rivafb_driver);
2029 }
2030
2031 module_init(rivafb_init);
2032 module_exit(rivafb_exit);
2033
2034 MODULE_PARM(flatpanel, "i");
2035 MODULE_PARM_DESC(flatpanel, "Enables experimental flat panel support for some chipsets. (0 or 1=enabled) (default=0)");
2036 MODULE_PARM(forceCRTC, "i");
2037 MODULE_PARM_DESC(forceCRTC, "Forces usage of a particular CRTC in case autodetection fails. (0 or 1) (default=autodetect)");
2038
2039 #ifdef CONFIG_MTRR
2040 MODULE_PARM(nomtrr, "i");
2041 MODULE_PARM_DESC(nomtrr, "Disables MTRR support (0 or 1=disabled) (default=0)");
2042 #endif
2043 #endif /* MODULE */
2044
2045 MODULE_AUTHOR("Ani Joshi, maintainer");
2046 MODULE_DESCRIPTION("Framebuffer driver for nVidia Riva 128, TNT, TNT2, and the GeForce series");
2047 MODULE_LICENSE("GPL");