drivers/video/aty/radeon_base.c

   1 /*
   2  *      drivers/video/aty/radeon_base.c
   3  *
   4  *      framebuffer driver for ATI Radeon chipset video boards
   5  *
   6  *      Copyright 2003  Ben. Herrenschmidt <benh@kernel.crashing.org>
   7  *      Copyright 2000  Ani Joshi <ajoshi@kernel.crashing.org>
   8  *
   9  *      i2c bits from Luca Tettamanti <kronos@kronoz.cjb.net>
  10  *
  11  *      Special thanks to ATI DevRel team for their hardware donations.
  12  *
  13  *      ...Insert GPL boilerplate here...
  14  *
  15  *      Significant portions of this driver apdated from XFree86 Radeon
  16  *      driver which has the following copyright notice:
  17  *
  18  *      Copyright 2000 ATI Technologies Inc., Markham, Ontario, and
  19  *                     VA Linux Systems Inc., Fremont, California.
  20  *
  21  *      All Rights Reserved.
  22  *
  23  *      Permission is hereby granted, free of charge, to any person obtaining
  24  *      a copy of this software and associated documentation files (the
  25  *      "Software"), to deal in the Software without restriction, including
  26  *      without limitation on the rights to use, copy, modify, merge,
  27  *      publish, distribute, sublicense, and/or sell copies of the Software,
  28  *      and to permit persons to whom the Software is furnished to do so,
  29  *      subject to the following conditions:
  30  *
  31  *      The above copyright notice and this permission notice (including the
  32  *      next paragraph) shall be included in all copies or substantial
  33  *      portions of the Software.
  34  *
  35  *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  36  *      EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  37  *      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  38  *      NON-INFRINGEMENT.  IN NO EVENT SHALL ATI, VA LINUX SYSTEMS AND/OR
  39  *      THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  40  *      WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  41  *      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  42  *      DEALINGS IN THE SOFTWARE.
  43  *
  44  *      XFree86 driver authors:
  45  *
  46  *         Kevin E. Martin <martin@xfree86.org>
  47  *         Rickard E. Faith <faith@valinux.com>
  48  *         Alan Hourihane <alanh@fairlite.demon.co.uk>
  49  *
  50  */
  51
  52
  53 #define RADEON_VERSION  "0.2.0"
  54
  55 #include <linux/module.h>
  56 #include <linux/moduleparam.h>
  57 #include <linux/kernel.h>
  58 #include <linux/errno.h>
  59 #include <linux/string.h>
  60 #include <linux/mm.h>
  61 #include <linux/slab.h>
  62 #include <linux/delay.h>
  63 #include <linux/time.h>
  64 #include <linux/fb.h>
  65 #include <linux/ioport.h>
  66 #include <linux/init.h>
  67 #include <linux/pci.h>
  68 #include <linux/vmalloc.h>
  69 #include <linux/device.h>
  70
  71 #include <asm/io.h>
  72 #include <linux/uaccess.h>
  73
  74 #ifdef CONFIG_PPC_OF
  75
  76 #include <asm/pci-bridge.h>
  77 #include "../macmodes.h"
  78
  79 #ifdef CONFIG_BOOTX_TEXT
  80 #include <asm/btext.h>
  81 #endif
  82
  83 #endif /* CONFIG_PPC_OF */
  84
  85 #ifdef CONFIG_MTRR
  86 #include <asm/mtrr.h>
  87 #endif
  88
  89 #include <video/radeon.h>
  90 #include <linux/radeonfb.h>
  91
  92 #include "../edid.h" // MOVE THAT TO include/video
  93 #include "ati_ids.h"
  94 #include "radeonfb.h"
  95
  96 #define MAX_MAPPED_VRAM (2048*2048*4)
  97 #define MIN_MAPPED_VRAM (1024*768*1)
  98
  99 #define CHIP_DEF(id, family, flags)                                     \
 100         { PCI_VENDOR_ID_ATI, id, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (flags) | (CHIP_FAMILY_##family) }
 101
 102 static struct pci_device_id radeonfb_pci_table[] = {
 103         /* Radeon Xpress 200m */
 104         CHIP_DEF(PCI_CHIP_RS480_5955,   RS480,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 105         CHIP_DEF(PCI_CHIP_RS482_5975,   RS480,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 106         /* Mobility M6 */
 107         CHIP_DEF(PCI_CHIP_RADEON_LY,    RV100,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 108         CHIP_DEF(PCI_CHIP_RADEON_LZ,    RV100,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 109         /* Radeon VE/7000 */
 110         CHIP_DEF(PCI_CHIP_RV100_QY,     RV100,  CHIP_HAS_CRTC2),
 111         CHIP_DEF(PCI_CHIP_RV100_QZ,     RV100,  CHIP_HAS_CRTC2),
 112         CHIP_DEF(PCI_CHIP_RN50,         RV100,  CHIP_HAS_CRTC2),
 113         /* Radeon IGP320M (U1) */
 114         CHIP_DEF(PCI_CHIP_RS100_4336,   RS100,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 115         /* Radeon IGP320 (A3) */
 116         CHIP_DEF(PCI_CHIP_RS100_4136,   RS100,  CHIP_HAS_CRTC2 | CHIP_IS_IGP),
 117         /* IGP330M/340M/350M (U2) */
 118         CHIP_DEF(PCI_CHIP_RS200_4337,   RS200,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 119         /* IGP330/340/350 (A4) */
 120         CHIP_DEF(PCI_CHIP_RS200_4137,   RS200,  CHIP_HAS_CRTC2 | CHIP_IS_IGP),
 121         /* Mobility 7000 IGP */
 122         CHIP_DEF(PCI_CHIP_RS250_4437,   RS200,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 123         /* 7000 IGP (A4+) */
 124         CHIP_DEF(PCI_CHIP_RS250_4237,   RS200,  CHIP_HAS_CRTC2 | CHIP_IS_IGP),
 125         /* 8500 AIW */
 126         CHIP_DEF(PCI_CHIP_R200_BB,      R200,   CHIP_HAS_CRTC2),
 127         CHIP_DEF(PCI_CHIP_R200_BC,      R200,   CHIP_HAS_CRTC2),
 128         /* 8700/8800 */
 129         CHIP_DEF(PCI_CHIP_R200_QH,      R200,   CHIP_HAS_CRTC2),
 130         /* 8500 */
 131         CHIP_DEF(PCI_CHIP_R200_QL,      R200,   CHIP_HAS_CRTC2),
 132         /* 9100 */
 133         CHIP_DEF(PCI_CHIP_R200_QM,      R200,   CHIP_HAS_CRTC2),
 134         /* Mobility M7 */
 135         CHIP_DEF(PCI_CHIP_RADEON_LW,    RV200,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 136         CHIP_DEF(PCI_CHIP_RADEON_LX,    RV200,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 137         /* 7500 */
 138         CHIP_DEF(PCI_CHIP_RV200_QW,     RV200,  CHIP_HAS_CRTC2),
 139         CHIP_DEF(PCI_CHIP_RV200_QX,     RV200,  CHIP_HAS_CRTC2),
 140         /* Mobility M9 */
 141         CHIP_DEF(PCI_CHIP_RV250_Ld,     RV250,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 142         CHIP_DEF(PCI_CHIP_RV250_Le,     RV250,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 143         CHIP_DEF(PCI_CHIP_RV250_Lf,     RV250,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 144         CHIP_DEF(PCI_CHIP_RV250_Lg,     RV250,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 145         /* 9000/Pro */
 146         CHIP_DEF(PCI_CHIP_RV250_If,     RV250,  CHIP_HAS_CRTC2),
 147         CHIP_DEF(PCI_CHIP_RV250_Ig,     RV250,  CHIP_HAS_CRTC2),
 148
 149         CHIP_DEF(PCI_CHIP_RC410_5A62,   RC410,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 150         /* Mobility 9100 IGP (U3) */
 151         CHIP_DEF(PCI_CHIP_RS300_5835,   RS300,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 152         CHIP_DEF(PCI_CHIP_RS350_7835,   RS300,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
 153         /* 9100 IGP (A5) */
 154         CHIP_DEF(PCI_CHIP_RS300_5834,   RS300,  CHIP_HAS_CRTC2 | CHIP_IS_IGP),
 155         CHIP_DEF(PCI_CHIP_RS350_7834,   RS300,  CHIP_HAS_CRTC2 | CHIP_IS_IGP),
 156         /* Mobility 9200 (M9+) */
 157         CHIP_DEF(PCI_CHIP_RV280_5C61,   RV280,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 158         CHIP_DEF(PCI_CHIP_RV280_5C63,   RV280,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 159         /* 9200 */
 160         CHIP_DEF(PCI_CHIP_RV280_5960,   RV280,  CHIP_HAS_CRTC2),
 161         CHIP_DEF(PCI_CHIP_RV280_5961,   RV280,  CHIP_HAS_CRTC2),
 162         CHIP_DEF(PCI_CHIP_RV280_5962,   RV280,  CHIP_HAS_CRTC2),
 163         CHIP_DEF(PCI_CHIP_RV280_5964,   RV280,  CHIP_HAS_CRTC2),
 164         /* 9500 */
 165         CHIP_DEF(PCI_CHIP_R300_AD,      R300,   CHIP_HAS_CRTC2),
 166         CHIP_DEF(PCI_CHIP_R300_AE,      R300,   CHIP_HAS_CRTC2),
 167         /* 9600TX / FireGL Z1 */
 168         CHIP_DEF(PCI_CHIP_R300_AF,      R300,   CHIP_HAS_CRTC2),
 169         CHIP_DEF(PCI_CHIP_R300_AG,      R300,   CHIP_HAS_CRTC2),
 170         /* 9700/9500/Pro/FireGL X1 */
 171         CHIP_DEF(PCI_CHIP_R300_ND,      R300,   CHIP_HAS_CRTC2),
 172         CHIP_DEF(PCI_CHIP_R300_NE,      R300,   CHIP_HAS_CRTC2),
 173         CHIP_DEF(PCI_CHIP_R300_NF,      R300,   CHIP_HAS_CRTC2),
 174         CHIP_DEF(PCI_CHIP_R300_NG,      R300,   CHIP_HAS_CRTC2),
 175         /* Mobility M10/M11 */
 176         CHIP_DEF(PCI_CHIP_RV350_NP,     RV350,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 177         CHIP_DEF(PCI_CHIP_RV350_NQ,     RV350,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 178         CHIP_DEF(PCI_CHIP_RV350_NR,     RV350,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 179         CHIP_DEF(PCI_CHIP_RV350_NS,     RV350,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 180         CHIP_DEF(PCI_CHIP_RV350_NT,     RV350,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 181         CHIP_DEF(PCI_CHIP_RV350_NV,     RV350,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 182         /* 9600/FireGL T2 */
 183         CHIP_DEF(PCI_CHIP_RV350_AP,     RV350,  CHIP_HAS_CRTC2),
 184         CHIP_DEF(PCI_CHIP_RV350_AQ,     RV350,  CHIP_HAS_CRTC2),
 185         CHIP_DEF(PCI_CHIP_RV360_AR,     RV350,  CHIP_HAS_CRTC2),
 186         CHIP_DEF(PCI_CHIP_RV350_AS,     RV350,  CHIP_HAS_CRTC2),
 187         CHIP_DEF(PCI_CHIP_RV350_AT,     RV350,  CHIP_HAS_CRTC2),
 188         CHIP_DEF(PCI_CHIP_RV350_AV,     RV350,  CHIP_HAS_CRTC2),
 189         /* 9800/Pro/FileGL X2 */
 190         CHIP_DEF(PCI_CHIP_R350_AH,      R350,   CHIP_HAS_CRTC2),
 191         CHIP_DEF(PCI_CHIP_R350_AI,      R350,   CHIP_HAS_CRTC2),
 192         CHIP_DEF(PCI_CHIP_R350_AJ,      R350,   CHIP_HAS_CRTC2),
 193         CHIP_DEF(PCI_CHIP_R350_AK,      R350,   CHIP_HAS_CRTC2),
 194         CHIP_DEF(PCI_CHIP_R350_NH,      R350,   CHIP_HAS_CRTC2),
 195         CHIP_DEF(PCI_CHIP_R350_NI,      R350,   CHIP_HAS_CRTC2),
 196         CHIP_DEF(PCI_CHIP_R360_NJ,      R350,   CHIP_HAS_CRTC2),
 197         CHIP_DEF(PCI_CHIP_R350_NK,      R350,   CHIP_HAS_CRTC2),
 198         /* Newer stuff */
 199         CHIP_DEF(PCI_CHIP_RV380_3E50,   RV380,  CHIP_HAS_CRTC2),
 200         CHIP_DEF(PCI_CHIP_RV380_3E54,   RV380,  CHIP_HAS_CRTC2),
 201         CHIP_DEF(PCI_CHIP_RV380_3150,   RV380,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 202         CHIP_DEF(PCI_CHIP_RV380_3154,   RV380,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 203         CHIP_DEF(PCI_CHIP_RV370_5B60,   RV380,  CHIP_HAS_CRTC2),
 204         CHIP_DEF(PCI_CHIP_RV370_5B62,   RV380,  CHIP_HAS_CRTC2),
 205         CHIP_DEF(PCI_CHIP_RV370_5B63,   RV380,  CHIP_HAS_CRTC2),
 206         CHIP_DEF(PCI_CHIP_RV370_5B64,   RV380,  CHIP_HAS_CRTC2),
 207         CHIP_DEF(PCI_CHIP_RV370_5B65,   RV380,  CHIP_HAS_CRTC2),
 208         CHIP_DEF(PCI_CHIP_RV370_5460,   RV380,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 209         CHIP_DEF(PCI_CHIP_RV370_5464,   RV380,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 210         CHIP_DEF(PCI_CHIP_R420_JH,      R420,   CHIP_HAS_CRTC2),
 211         CHIP_DEF(PCI_CHIP_R420_JI,      R420,   CHIP_HAS_CRTC2),
 212         CHIP_DEF(PCI_CHIP_R420_JJ,      R420,   CHIP_HAS_CRTC2),
 213         CHIP_DEF(PCI_CHIP_R420_JK,      R420,   CHIP_HAS_CRTC2),
 214         CHIP_DEF(PCI_CHIP_R420_JL,      R420,   CHIP_HAS_CRTC2),
 215         CHIP_DEF(PCI_CHIP_R420_JM,      R420,   CHIP_HAS_CRTC2),
 216         CHIP_DEF(PCI_CHIP_R420_JN,      R420,   CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
 217         CHIP_DEF(PCI_CHIP_R420_JP,      R420,   CHIP_HAS_CRTC2),
 218         CHIP_DEF(PCI_CHIP_R423_UH,      R420,   CHIP_HAS_CRTC2),
 219         CHIP_DEF(PCI_CHIP_R423_UI,      R420,   CHIP_HAS_CRTC2),
 220         CHIP_DEF(PCI_CHIP_R423_UJ,      R420,   CHIP_HAS_CRTC2),
 221         CHIP_DEF(PCI_CHIP_R423_UK,      R420,   CHIP_HAS_CRTC2),
 222         CHIP_DEF(PCI_CHIP_R423_UQ,      R420,   CHIP_HAS_CRTC2),
 223         CHIP_DEF(PCI_CHIP_R423_UR,      R420,   CHIP_HAS_CRTC2),
 224         CHIP_DEF(PCI_CHIP_R423_UT,      R420,   CHIP_HAS_CRTC2),
 225         CHIP_DEF(PCI_CHIP_R423_5D57,    R420,   CHIP_HAS_CRTC2),
 226         /* Original Radeon/7200 */
 227         CHIP_DEF(PCI_CHIP_RADEON_QD,    RADEON, 0),
 228         CHIP_DEF(PCI_CHIP_RADEON_QE,    RADEON, 0),
 229         CHIP_DEF(PCI_CHIP_RADEON_QF,    RADEON, 0),
 230         CHIP_DEF(PCI_CHIP_RADEON_QG,    RADEON, 0),
 231         { 0, }
 232 };
 233 MODULE_DEVICE_TABLE(pci, radeonfb_pci_table);
 234
 235
 236 typedef struct {
 237         u16 reg;
 238         u32 val;
 239 } reg_val;
 240
 241
 242 /* these common regs are cleared before mode setting so they do not
 243  * interfere with anything
 244  */
 245 static reg_val common_regs[] = {
 246         { OVR_CLR, 0 },
 247         { OVR_WID_LEFT_RIGHT, 0 },
 248         { OVR_WID_TOP_BOTTOM, 0 },
 249         { OV0_SCALE_CNTL, 0 },
 250         { SUBPIC_CNTL, 0 },
 251         { VIPH_CONTROL, 0 },
 252         { I2C_CNTL_1, 0 },
 253         { GEN_INT_CNTL, 0 },
 254         { CAP0_TRIG_CNTL, 0 },
 255         { CAP1_TRIG_CNTL, 0 },
 256 };
 257
 258 /*
 259  * globals
 260  */
 261
 262 static char *mode_option;
 263 static char *monitor_layout;
 264 static int noaccel = 0;
 265 static int default_dynclk = -2;
 266 static int nomodeset = 0;
 267 static int ignore_edid = 0;
 268 static int mirror = 0;
 269 static int panel_yres = 0;
 270 static int force_dfp = 0;
 271 static int force_measure_pll = 0;
 272 #ifdef CONFIG_MTRR
 273 static int nomtrr = 0;
 274 #endif
 275 static int force_sleep;
 276 static int ignore_devlist;
 277 #ifdef CONFIG_PMAC_BACKLIGHT
 278 static int backlight = 1;
 279 #else
 280 static int backlight = 0;
 281 #endif
 282
 283 /*
 284  * prototypes
 285  */
 286
 287 static void radeon_unmap_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev)
 288 {
 289         if (!rinfo->bios_seg)
 290                 return;
 291         pci_unmap_rom(dev, rinfo->bios_seg);
 292 }
 293
 294 static int __devinit radeon_map_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev)
 295 {
 296         void __iomem *rom;
 297         u16 dptr;
 298         u8 rom_type;
 299         size_t rom_size;
 300
 301         /* If this is a primary card, there is a shadow copy of the
 302          * ROM somewhere in the first meg. We will just ignore the copy
 303          * and use the ROM directly.
 304          */
 305
 306         /* Fix from ATI for problem with Radeon hardware not leaving ROM enabled */
 307         unsigned int temp;
 308         temp = INREG(MPP_TB_CONFIG);
 309         temp &= 0x00ffffffu;
 310         temp |= 0x04 << 24;
 311         OUTREG(MPP_TB_CONFIG, temp);
 312         temp = INREG(MPP_TB_CONFIG);
 313
 314         rom = pci_map_rom(dev, &rom_size);
 315         if (!rom) {
 316                 printk(KERN_ERR "radeonfb (%s): ROM failed to map\n",
 317                        pci_name(rinfo->pdev));
 318                 return -ENOMEM;
 319         }
 320
 321         rinfo->bios_seg = rom;
 322
 323         /* Very simple test to make sure it appeared */
 324         if (BIOS_IN16(0) != 0xaa55) {
 325                 printk(KERN_DEBUG "radeonfb (%s): Invalid ROM signature %x "
 326                         "should be 0xaa55\n",
 327                         pci_name(rinfo->pdev), BIOS_IN16(0));
 328                 goto failed;
 329         }
 330         /* Look for the PCI data to check the ROM type */
 331         dptr = BIOS_IN16(0x18);
 332
 333         /* Check the PCI data signature. If it's wrong, we still assume a normal x86 ROM
 334          * for now, until I've verified this works everywhere. The goal here is more
 335          * to phase out Open Firmware images.
 336          *
 337          * Currently, we only look at the first PCI data, we could iteratre and deal with
 338          * them all, and we should use fb_bios_start relative to start of image and not
 339          * relative start of ROM, but so far, I never found a dual-image ATI card
 340          *
 341          * typedef struct {
 342          *      u32     signature;      + 0x00
 343          *      u16     vendor;         + 0x04
 344          *      u16     device;         + 0x06
 345          *      u16     reserved_1;     + 0x08
 346          *      u16     dlen;           + 0x0a
 347          *      u8      drevision;      + 0x0c
 348          *      u8      class_hi;       + 0x0d
 349          *      u16     class_lo;       + 0x0e
 350          *      u16     ilen;           + 0x10
 351          *      u16     irevision;      + 0x12
 352          *      u8      type;           + 0x14
 353          *      u8      indicator;      + 0x15
 354          *      u16     reserved_2;     + 0x16
 355          * } pci_data_t;
 356          */
 357         if (BIOS_IN32(dptr) !=  (('R' << 24) | ('I' << 16) | ('C' << 8) | 'P')) {
 358                 printk(KERN_WARNING "radeonfb (%s): PCI DATA signature in ROM"
 359                        "incorrect: %08x\n", pci_name(rinfo->pdev), BIOS_IN32(dptr));
 360                 goto anyway;
 361         }
 362         rom_type = BIOS_IN8(dptr + 0x14);
 363         switch(rom_type) {
 364         case 0:
 365                 printk(KERN_INFO "radeonfb: Found Intel x86 BIOS ROM Image\n");
 366                 break;
 367         case 1:
 368                 printk(KERN_INFO "radeonfb: Found Open Firmware ROM Image\n");
 369                 goto failed;
 370         case 2:
 371                 printk(KERN_INFO "radeonfb: Found HP PA-RISC ROM Image\n");
 372                 goto failed;
 373         default:
 374                 printk(KERN_INFO "radeonfb: Found unknown type %d ROM Image\n", rom_type);
 375                 goto failed;
 376         }
 377  anyway:
 378         /* Locate the flat panel infos, do some sanity checking !!! */
 379         rinfo->fp_bios_start = BIOS_IN16(0x48);
 380         return 0;
 381
 382  failed:
 383         rinfo->bios_seg = NULL;
 384         radeon_unmap_ROM(rinfo, dev);
 385         return -ENXIO;
 386 }
 387
 388 #ifdef CONFIG_X86
 389 static int  __devinit radeon_find_mem_vbios(struct radeonfb_info *rinfo)
 390 {
 391         /* I simplified this code as we used to miss the signatures in
 392          * a lot of case. It's now closer to XFree, we just don't check
 393          * for signatures at all... Something better will have to be done
 394          * if we end up having conflicts
 395          */
 396         u32  segstart;
 397         void __iomem *rom_base = NULL;
 398
 399         for(segstart=0x000c0000; segstart<0x000f0000; segstart+=0x00001000) {
 400                 rom_base = ioremap(segstart, 0x10000);
 401                 if (rom_base == NULL)
 402                         return -ENOMEM;
 403                 if (readb(rom_base) == 0x55 && readb(rom_base + 1) == 0xaa)
 404                         break;
 405                 iounmap(rom_base);
 406                 rom_base = NULL;
 407         }
 408         if (rom_base == NULL)
 409                 return -ENXIO;
 410
 411         /* Locate the flat panel infos, do some sanity checking !!! */
 412         rinfo->bios_seg = rom_base;
 413         rinfo->fp_bios_start = BIOS_IN16(0x48);
 414
 415         return 0;
 416 }
 417 #endif
 418
 419 #if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
 420 /*
 421  * Read XTAL (ref clock), SCLK and MCLK from Open Firmware device
 422  * tree. Hopefully, ATI OF driver is kind enough to fill these
 423  */
 424 static int __devinit radeon_read_xtal_OF (struct radeonfb_info *rinfo)
 425 {
 426         struct device_node *dp = rinfo->of_node;
 427         const u32 *val;
 428
 429         if (dp == NULL)
 430                 return -ENODEV;
 431         val = of_get_property(dp, "ATY,RefCLK", NULL);
 432         if (!val || !*val) {
 433                 printk(KERN_WARNING "radeonfb: No ATY,RefCLK property !\n");
 434                 return -EINVAL;
 435         }
 436
 437         rinfo->pll.ref_clk = (*val) / 10;
 438
 439         val = of_get_property(dp, "ATY,SCLK", NULL);
 440         if (val && *val)
 441                 rinfo->pll.sclk = (*val) / 10;
 442
 443         val = of_get_property(dp, "ATY,MCLK", NULL);
 444         if (val && *val)
 445                 rinfo->pll.mclk = (*val) / 10;
 446
 447         return 0;
 448 }
 449 #endif /* CONFIG_PPC_OF || CONFIG_SPARC */
 450
 451 /*
 452  * Read PLL infos from chip registers
 453  */
 454 static int __devinit radeon_probe_pll_params(struct radeonfb_info *rinfo)
 455 {
 456         unsigned char ppll_div_sel;
 457         unsigned Ns, Nm, M;
 458         unsigned sclk, mclk, tmp, ref_div;
 459         int hTotal, vTotal, num, denom, m, n;
 460         unsigned long long hz, vclk;
 461         long xtal;
 462         struct timeval start_tv, stop_tv;
 463         long total_secs, total_usecs;
 464         int i;
 465
 466         /* Ugh, we cut interrupts, bad bad bad, but we want some precision
 467          * here, so... --BenH
 468          */
 469
 470         /* Flush PCI buffers ? */
 471         tmp = INREG16(DEVICE_ID);
 472
 473         local_irq_disable();
 474
 475         for(i=0; i<1000000; i++)
 476                 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) == 0)
 477                         break;
 478
 479         do_gettimeofday(&start_tv);
 480
 481         for(i=0; i<1000000; i++)
 482                 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) != 0)
 483                         break;
 484
 485         for(i=0; i<1000000; i++)
 486                 if (((INREG(CRTC_VLINE_CRNT_VLINE) >> 16) & 0x3ff) == 0)
 487                         break;
 488
 489         do_gettimeofday(&stop_tv);
 490
 491         local_irq_enable();
 492
 493         total_secs = stop_tv.tv_sec - start_tv.tv_sec;
 494         if (total_secs > 10)
 495                 return -1;
 496         total_usecs = stop_tv.tv_usec - start_tv.tv_usec;
 497         total_usecs += total_secs * 1000000;
 498         if (total_usecs < 0)
 499                 total_usecs = -total_usecs;
 500         hz = 1000000/total_usecs;
 501
 502         hTotal = ((INREG(CRTC_H_TOTAL_DISP) & 0x1ff) + 1) * 8;
 503         vTotal = ((INREG(CRTC_V_TOTAL_DISP) & 0x3ff) + 1);
 504         vclk = (long long)hTotal * (long long)vTotal * hz;
 505
 506         switch((INPLL(PPLL_REF_DIV) & 0x30000) >> 16) {
 507         case 0:
 508         default:
 509                 num = 1;
 510                 denom = 1;
 511                 break;
 512         case 1:
 513                 n = ((INPLL(M_SPLL_REF_FB_DIV) >> 16) & 0xff);
 514                 m = (INPLL(M_SPLL_REF_FB_DIV) & 0xff);
 515                 num = 2*n;
 516                 denom = 2*m;
 517                 break;
 518         case 2:
 519                 n = ((INPLL(M_SPLL_REF_FB_DIV) >> 8) & 0xff);
 520                 m = (INPLL(M_SPLL_REF_FB_DIV) & 0xff);
 521                 num = 2*n;
 522                 denom = 2*m;
 523         break;
 524         }
 525
 526         ppll_div_sel = INREG8(CLOCK_CNTL_INDEX + 1) & 0x3;
 527         radeon_pll_errata_after_index(rinfo);
 528
 529         n = (INPLL(PPLL_DIV_0 + ppll_div_sel) & 0x7ff);
 530         m = (INPLL(PPLL_REF_DIV) & 0x3ff);
 531
 532         num *= n;
 533         denom *= m;
 534
 535         switch ((INPLL(PPLL_DIV_0 + ppll_div_sel) >> 16) & 0x7) {
 536         case 1:
 537                 denom *= 2;
 538                 break;
 539         case 2:
 540                 denom *= 4;
 541                 break;
 542         case 3:
 543                 denom *= 8;
 544                 break;
 545         case 4:
 546                 denom *= 3;
 547                 break;
 548         case 6:
 549                 denom *= 6;
 550                 break;
 551         case 7:
 552                 denom *= 12;
 553                 break;
 554         }
 555
 556         vclk *= denom;
 557         do_div(vclk, 1000 * num);
 558         xtal = vclk;
 559
 560         if ((xtal > 26900) && (xtal < 27100))
 561                 xtal = 2700;
 562         else if ((xtal > 14200) && (xtal < 14400))
 563                 xtal = 1432;
 564         else if ((xtal > 29400) && (xtal < 29600))
 565                 xtal = 2950;
 566         else {
 567                 printk(KERN_WARNING "xtal calculation failed: %ld\n", xtal);
 568                 return -1;
 569         }
 570
 571         tmp = INPLL(M_SPLL_REF_FB_DIV);
 572         ref_div = INPLL(PPLL_REF_DIV) & 0x3ff;
 573
 574         Ns = (tmp & 0xff0000) >> 16;
 575         Nm = (tmp & 0xff00) >> 8;
 576         M = (tmp & 0xff);
 577         sclk = round_div((2 * Ns * xtal), (2 * M));
 578         mclk = round_div((2 * Nm * xtal), (2 * M));
 579
 580         /* we're done, hopefully these are sane values */
 581         rinfo->pll.ref_clk = xtal;
 582         rinfo->pll.ref_div = ref_div;
 583         rinfo->pll.sclk = sclk;
 584         rinfo->pll.mclk = mclk;
 585
 586         return 0;
 587 }
 588
 589 /*
 590  * Retrieve PLL infos by different means (BIOS, Open Firmware, register probing...)
 591  */
 592 static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo)
 593 {
 594         /*
 595          * In the case nothing works, these are defaults; they are mostly
 596          * incomplete, however.  It does provide ppll_max and _min values
 597          * even for most other methods, however.
 598          */
 599         switch (rinfo->chipset) {
 600         case PCI_DEVICE_ID_ATI_RADEON_QW:
 601         case PCI_DEVICE_ID_ATI_RADEON_QX:
 602                 rinfo->pll.ppll_max = 35000;
 603                 rinfo->pll.ppll_min = 12000;
 604                 rinfo->pll.mclk = 23000;
 605                 rinfo->pll.sclk = 23000;
 606                 rinfo->pll.ref_clk = 2700;
 607                 break;
 608         case PCI_DEVICE_ID_ATI_RADEON_QL:
 609         case PCI_DEVICE_ID_ATI_RADEON_QN:
 610         case PCI_DEVICE_ID_ATI_RADEON_QO:
 611         case PCI_DEVICE_ID_ATI_RADEON_Ql:
 612         case PCI_DEVICE_ID_ATI_RADEON_BB:
 613                 rinfo->pll.ppll_max = 35000;
 614                 rinfo->pll.ppll_min = 12000;
 615                 rinfo->pll.mclk = 27500;
 616                 rinfo->pll.sclk = 27500;
 617                 rinfo->pll.ref_clk = 2700;
 618                 break;
 619         case PCI_DEVICE_ID_ATI_RADEON_Id:
 620         case PCI_DEVICE_ID_ATI_RADEON_Ie:
 621         case PCI_DEVICE_ID_ATI_RADEON_If:
 622         case PCI_DEVICE_ID_ATI_RADEON_Ig:
 623                 rinfo->pll.ppll_max = 35000;
 624                 rinfo->pll.ppll_min = 12000;
 625                 rinfo->pll.mclk = 25000;
 626                 rinfo->pll.sclk = 25000;
 627                 rinfo->pll.ref_clk = 2700;
 628                 break;
 629         case PCI_DEVICE_ID_ATI_RADEON_ND:
 630         case PCI_DEVICE_ID_ATI_RADEON_NE:
 631         case PCI_DEVICE_ID_ATI_RADEON_NF:
 632         case PCI_DEVICE_ID_ATI_RADEON_NG:
 633                 rinfo->pll.ppll_max = 40000;
 634                 rinfo->pll.ppll_min = 20000;
 635                 rinfo->pll.mclk = 27000;
 636                 rinfo->pll.sclk = 27000;
 637                 rinfo->pll.ref_clk = 2700;
 638                 break;
 639         case PCI_DEVICE_ID_ATI_RADEON_QD:
 640         case PCI_DEVICE_ID_ATI_RADEON_QE:
 641         case PCI_DEVICE_ID_ATI_RADEON_QF:
 642         case PCI_DEVICE_ID_ATI_RADEON_QG:
 643         default:
 644                 rinfo->pll.ppll_max = 35000;
 645                 rinfo->pll.ppll_min = 12000;
 646                 rinfo->pll.mclk = 16600;
 647                 rinfo->pll.sclk = 16600;
 648                 rinfo->pll.ref_clk = 2700;
 649                 break;
 650         }
 651         rinfo->pll.ref_div = INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK;
 652
 653
 654 #if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
 655         /*
 656          * Retrieve PLL infos from Open Firmware first
 657          */
 658         if (!force_measure_pll && radeon_read_xtal_OF(rinfo) == 0) {
 659                 printk(KERN_INFO "radeonfb: Retrieved PLL infos from Open Firmware\n");
 660                 goto found;
 661         }
 662 #endif /* CONFIG_PPC_OF || CONFIG_SPARC */
 663
 664         /*
 665          * Check out if we have an X86 which gave us some PLL informations
 666          * and if yes, retrieve them
 667          */
 668         if (!force_measure_pll && rinfo->bios_seg) {
 669                 u16 pll_info_block = BIOS_IN16(rinfo->fp_bios_start + 0x30);
 670
 671                 rinfo->pll.sclk         = BIOS_IN16(pll_info_block + 0x08);
 672                 rinfo->pll.mclk         = BIOS_IN16(pll_info_block + 0x0a);
 673                 rinfo->pll.ref_clk      = BIOS_IN16(pll_info_block + 0x0e);
 674                 rinfo->pll.ref_div      = BIOS_IN16(pll_info_block + 0x10);
 675                 rinfo->pll.ppll_min     = BIOS_IN32(pll_info_block + 0x12);
 676                 rinfo->pll.ppll_max     = BIOS_IN32(pll_info_block + 0x16);
 677
 678                 printk(KERN_INFO "radeonfb: Retrieved PLL infos from BIOS\n");
 679                 goto found;
 680         }
 681
 682         /*
 683          * We didn't get PLL parameters from either OF or BIOS, we try to
 684          * probe them
 685          */
 686         if (radeon_probe_pll_params(rinfo) == 0) {
 687                 printk(KERN_INFO "radeonfb: Retrieved PLL infos from registers\n");
 688                 goto found;
 689         }
 690
 691         /*
 692          * Fall back to already-set defaults...
 693          */
 694         printk(KERN_INFO "radeonfb: Used default PLL infos\n");
 695
 696 found:
 697         /*
 698          * Some methods fail to retrieve SCLK and MCLK values, we apply default
 699          * settings in this case (200Mhz). If that really happne often, we could
 700          * fetch from registers instead...
 701          */
 702         if (rinfo->pll.mclk == 0)
 703                 rinfo->pll.mclk = 20000;
 704         if (rinfo->pll.sclk == 0)
 705                 rinfo->pll.sclk = 20000;
 706
 707         printk("radeonfb: Reference=%d.%02d MHz (RefDiv=%d) Memory=%d.%02d Mhz, System=%d.%02d MHz\n",
 708                rinfo->pll.ref_clk / 100, rinfo->pll.ref_clk % 100,
 709                rinfo->pll.ref_div,
 710                rinfo->pll.mclk / 100, rinfo->pll.mclk % 100,
 711                rinfo->pll.sclk / 100, rinfo->pll.sclk % 100);
 712         printk("radeonfb: PLL min %d max %d\n", rinfo->pll.ppll_min, rinfo->pll.ppll_max);
 713 }
 714
 715 static int radeonfb_check_var (struct fb_var_screeninfo *var, struct fb_info *info)
 716 {
 717         struct radeonfb_info *rinfo = info->par;
 718         struct fb_var_screeninfo v;
 719         int nom, den;
 720         unsigned int pitch;
 721
 722         if (radeon_match_mode(rinfo, &v, var))
 723                 return -EINVAL;
 724
 725         switch (v.bits_per_pixel) {
 726                 case 0 ... 8:
 727                         v.bits_per_pixel = 8;
 728                         break;
 729                 case 9 ... 16:
 730                         v.bits_per_pixel = 16;
 731                         break;
 732                 case 17 ... 24:
 733 #if 0 /* Doesn't seem to work */
 734                         v.bits_per_pixel = 24;
 735                         break;
 736 #endif
 737                         return -EINVAL;
 738                 case 25 ... 32:
 739                         v.bits_per_pixel = 32;
 740                         break;
 741                 default:
 742                         return -EINVAL;
 743         }
 744
 745         switch (var_to_depth(&v)) {
 746                 case 8:
 747                         nom = den = 1;
 748                         v.red.offset = v.green.offset = v.blue.offset = 0;
 749                         v.red.length = v.green.length = v.blue.length = 8;
 750                         v.transp.offset = v.transp.length = 0;
 751                         break;
 752                 case 15:
 753                         nom = 2;
 754                         den = 1;
 755                         v.red.offset = 10;
 756                         v.green.offset = 5;
 757                         v.blue.offset = 0;
 758                         v.red.length = v.green.length = v.blue.length = 5;
 759                         v.transp.offset = v.transp.length = 0;
 760                         break;
 761                 case 16:
 762                         nom = 2;
 763                         den = 1;
 764                         v.red.offset = 11;
 765                         v.green.offset = 5;
 766                         v.blue.offset = 0;
 767                         v.red.length = 5;
 768                         v.green.length = 6;
 769                         v.blue.length = 5;
 770                         v.transp.offset = v.transp.length = 0;
 771                         break;
 772                 case 24:
 773                         nom = 4;
 774                         den = 1;
 775                         v.red.offset = 16;
 776                         v.green.offset = 8;
 777                         v.blue.offset = 0;
 778                         v.red.length = v.blue.length = v.green.length = 8;
 779                         v.transp.offset = v.transp.length = 0;
 780                         break;
 781                 case 32:
 782                         nom = 4;
 783                         den = 1;
 784                         v.red.offset = 16;
 785                         v.green.offset = 8;
 786                         v.blue.offset = 0;
 787                         v.red.length = v.blue.length = v.green.length = 8;
 788                         v.transp.offset = 24;
 789                         v.transp.length = 8;
 790                         break;
 791                 default:
 792                         printk ("radeonfb: mode %dx%dx%d rejected, color depth invalid\n",
 793                                 var->xres, var->yres, var->bits_per_pixel);
 794                         return -EINVAL;
 795         }
 796
 797         if (v.yres_virtual < v.yres)
 798                 v.yres_virtual = v.yres;
 799         if (v.xres_virtual < v.xres)
 800                 v.xres_virtual = v.xres;
 801
 802
 803         /* XXX I'm adjusting xres_virtual to the pitch, that may help XFree
 804          * with some panels, though I don't quite like this solution
 805          */
 806         if (rinfo->info->flags & FBINFO_HWACCEL_DISABLED) {
 807                 v.xres_virtual = v.xres_virtual & ~7ul;
 808         } else {
 809                 pitch = ((v.xres_virtual * ((v.bits_per_pixel + 1) / 8) + 0x3f)
 810                                 & ~(0x3f)) >> 6;
 811                 v.xres_virtual = (pitch << 6) / ((v.bits_per_pixel + 1) / 8);
 812         }
 813
 814         if (((v.xres_virtual * v.yres_virtual * nom) / den) > rinfo->mapped_vram)
 815                 return -EINVAL;
 816
 817         if (v.xres_virtual < v.xres)
 818                 v.xres = v.xres_virtual;
 819
 820         if (v.xoffset < 0)
 821                 v.xoffset = 0;
 822         if (v.yoffset < 0)
 823                 v.yoffset = 0;
 824
 825         if (v.xoffset > v.xres_virtual - v.xres)
 826                 v.xoffset = v.xres_virtual - v.xres - 1;
 827
 828         if (v.yoffset > v.yres_virtual - v.yres)
 829                 v.yoffset = v.yres_virtual - v.yres - 1;
 830
 831         v.red.msb_right = v.green.msb_right = v.blue.msb_right =
 832                           v.transp.offset = v.transp.length =
 833                           v.transp.msb_right = 0;
 834
 835         memcpy(var, &v, sizeof(v));
 836
 837         return 0;
 838 }
 839
 840
 841 static int radeonfb_pan_display (struct fb_var_screeninfo *var,
 842                                  struct fb_info *info)
 843 {
 844         struct radeonfb_info *rinfo = info->par;
 845
 846         if ((var->xoffset + var->xres > var->xres_virtual)
 847             || (var->yoffset + var->yres > var->yres_virtual))
 848                return -EINVAL;
 849
 850         if (rinfo->asleep)
 851                 return 0;
 852
 853         radeon_fifo_wait(2);
 854         OUTREG(CRTC_OFFSET, ((var->yoffset * var->xres_virtual + var->xoffset)
 855                              * var->bits_per_pixel / 8) & ~7);
 856         return 0;
 857 }
 858
 859
 860 static int radeonfb_ioctl (struct fb_info *info, unsigned int cmd,
 861                            unsigned long arg)
 862 {
 863         struct radeonfb_info *rinfo = info->par;
 864         unsigned int tmp;
 865         u32 value = 0;
 866         int rc;
 867
 868         switch (cmd) {
 869                 /*
 870                  * TODO:  set mirror accordingly for non-Mobility chipsets with 2 CRTC's
 871                  *        and do something better using 2nd CRTC instead of just hackish
 872                  *        routing to second output
 873                  */
 874                 case FBIO_RADEON_SET_MIRROR:
 875                         if (!rinfo->is_mobility)
 876                                 return -EINVAL;
 877
 878                         rc = get_user(value, (__u32 __user *)arg);
 879
 880                         if (rc)
 881                                 return rc;
 882
 883                         radeon_fifo_wait(2);
 884                         if (value & 0x01) {
 885                                 tmp = INREG(LVDS_GEN_CNTL);
 886
 887                                 tmp |= (LVDS_ON | LVDS_BLON);
 888                         } else {
 889                                 tmp = INREG(LVDS_GEN_CNTL);
 890
 891                                 tmp &= ~(LVDS_ON | LVDS_BLON);
 892                         }
 893
 894                         OUTREG(LVDS_GEN_CNTL, tmp);
 895
 896                         if (value & 0x02) {
 897                                 tmp = INREG(CRTC_EXT_CNTL);
 898                                 tmp |= CRTC_CRT_ON;
 899
 900                                 mirror = 1;
 901                         } else {
 902                                 tmp = INREG(CRTC_EXT_CNTL);
 903                                 tmp &= ~CRTC_CRT_ON;
 904
 905                                 mirror = 0;
 906                         }
 907
 908                         OUTREG(CRTC_EXT_CNTL, tmp);
 909
 910                         return 0;
 911                 case FBIO_RADEON_GET_MIRROR:
 912                         if (!rinfo->is_mobility)
 913                                 return -EINVAL;
 914
 915                         tmp = INREG(LVDS_GEN_CNTL);
 916                         if ((LVDS_ON | LVDS_BLON) & tmp)
 917                                 value |= 0x01;
 918
 919                         tmp = INREG(CRTC_EXT_CNTL);
 920                         if (CRTC_CRT_ON & tmp)
 921                                 value |= 0x02;
 922
 923                         return put_user(value, (__u32 __user *)arg);
 924                 default:
 925                         return -EINVAL;
 926         }
 927
 928         return -EINVAL;
 929 }
 930
 931
 932 int radeon_screen_blank(struct radeonfb_info *rinfo, int blank, int mode_switch)
 933 {
 934         u32 val;
 935         u32 tmp_pix_clks;
 936         int unblank = 0;
 937
 938         if (rinfo->lock_blank)
 939                 return 0;
 940
 941         radeon_engine_idle();
 942
 943         val = INREG(CRTC_EXT_CNTL);
 944         val &= ~(CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS |
 945                  CRTC_VSYNC_DIS);
 946         switch (blank) {
 947         case FB_BLANK_VSYNC_SUSPEND:
 948                 val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS);
 949                 break;
 950         case FB_BLANK_HSYNC_SUSPEND:
 951                 val |= (CRTC_DISPLAY_DIS | CRTC_HSYNC_DIS);
 952                 break;
 953         case FB_BLANK_POWERDOWN:
 954                 val |= (CRTC_DISPLAY_DIS | CRTC_VSYNC_DIS |
 955                         CRTC_HSYNC_DIS);
 956                 break;
 957         case FB_BLANK_NORMAL:
 958                 val |= CRTC_DISPLAY_DIS;
 959                 break;
 960         case FB_BLANK_UNBLANK:
 961         default:
 962                 unblank = 1;
 963         }
 964         OUTREG(CRTC_EXT_CNTL, val);
 965
 966
 967         switch (rinfo->mon1_type) {
 968         case MT_DFP:
 969                 if (unblank)
 970                         OUTREGP(FP_GEN_CNTL, (FP_FPON | FP_TMDS_EN),
 971                                 ~(FP_FPON | FP_TMDS_EN));
 972                 else {
 973                         if (mode_switch || blank == FB_BLANK_NORMAL)
 974                                 break;
 975                         OUTREGP(FP_GEN_CNTL, 0, ~(FP_FPON | FP_TMDS_EN));
 976                 }
 977                 break;
 978         case MT_LCD:
 979                 del_timer_sync(&rinfo->lvds_timer);
 980                 val = INREG(LVDS_GEN_CNTL);
 981                 if (unblank) {
 982                         u32 target_val = (val & ~LVDS_DISPLAY_DIS) | LVDS_BLON | LVDS_ON
 983                                 | LVDS_EN | (rinfo->init_state.lvds_gen_cntl
 984                                              & (LVDS_DIGON | LVDS_BL_MOD_EN));
 985                         if ((val ^ target_val) == LVDS_DISPLAY_DIS)
 986                                 OUTREG(LVDS_GEN_CNTL, target_val);
 987                         else if ((val ^ target_val) != 0) {
 988                                 OUTREG(LVDS_GEN_CNTL, target_val
 989                                        & ~(LVDS_ON | LVDS_BL_MOD_EN));
 990                                 rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
 991                                 rinfo->init_state.lvds_gen_cntl |=
 992                                         target_val & LVDS_STATE_MASK;
 993                                 if (mode_switch) {
 994                                         radeon_msleep(rinfo->panel_info.pwr_delay);
 995                                         OUTREG(LVDS_GEN_CNTL, target_val);
 996                                 }
 997                                 else {
 998                                         rinfo->pending_lvds_gen_cntl = target_val;
 999                                         mod_timer(&rinfo->lvds_timer,
1000                                            jiffies +
1001                                            msecs_to_jiffies(rinfo->panel_info.pwr_delay));
1002                                 }
1003                         }
1004                 } else {
1005                         val |= LVDS_DISPLAY_DIS;
1006                         OUTREG(LVDS_GEN_CNTL, val);
1007
1008                         /* We don't do a full switch-off on a simple mode switch */
1009                         if (mode_switch || blank == FB_BLANK_NORMAL)
1010                                 break;
1011
1012                         /* Asic bug, when turning off LVDS_ON, we have to make sure
1013                          * RADEON_PIXCLK_LVDS_ALWAYS_ON bit is off
1014                          */
1015                         tmp_pix_clks = INPLL(PIXCLKS_CNTL);
1016                         if (rinfo->is_mobility || rinfo->is_IGP)
1017                                 OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
1018                         val &= ~(LVDS_BL_MOD_EN);
1019                         OUTREG(LVDS_GEN_CNTL, val);
1020                         udelay(100);
1021                         val &= ~(LVDS_ON | LVDS_EN);
1022                         OUTREG(LVDS_GEN_CNTL, val);
1023                         val &= ~LVDS_DIGON;
1024                         rinfo->pending_lvds_gen_cntl = val;
1025                         mod_timer(&rinfo->lvds_timer,
1026                                   jiffies +
1027                                   msecs_to_jiffies(rinfo->panel_info.pwr_delay));
1028                         rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
1029                         rinfo->init_state.lvds_gen_cntl |= val & LVDS_STATE_MASK;
1030                         if (rinfo->is_mobility || rinfo->is_IGP)
1031                                 OUTPLL(PIXCLKS_CNTL, tmp_pix_clks);
1032                 }
1033                 break;
1034         case MT_CRT:
1035                 // todo: powerdown DAC
1036         default:
1037                 break;
1038         }
1039
1040         return 0;
1041 }
1042
1043 static int radeonfb_blank (int blank, struct fb_info *info)
1044 {
1045         struct radeonfb_info *rinfo = info->par;
1046
1047         if (rinfo->asleep)
1048                 return 0;
1049
1050         return radeon_screen_blank(rinfo, blank, 0);
1051 }
1052
1053 static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
1054                              unsigned blue, unsigned transp,
1055                              struct radeonfb_info *rinfo)
1056 {
1057         u32 pindex;
1058         unsigned int i;
1059
1060
1061         if (regno > 255)
1062                 return -EINVAL;
1063
1064         red >>= 8;
1065         green >>= 8;
1066         blue >>= 8;
1067         rinfo->palette[regno].red = red;
1068         rinfo->palette[regno].green = green;
1069         rinfo->palette[regno].blue = blue;
1070
1071         /* default */
1072         pindex = regno;
1073
1074         if (!rinfo->asleep) {
1075                 radeon_fifo_wait(9);
1076
1077                 if (rinfo->bpp == 16) {
1078                         pindex = regno * 8;
1079
1080                         if (rinfo->depth == 16 && regno > 63)
1081                                 return -EINVAL;
1082                         if (rinfo->depth == 15 && regno > 31)
1083                                 return -EINVAL;
1084
1085                         /* For 565, the green component is mixed one order
1086                          * below
1087                          */
1088                         if (rinfo->depth == 16) {
1089                                 OUTREG(PALETTE_INDEX, pindex>>1);
1090                                 OUTREG(PALETTE_DATA,
1091                                        (rinfo->palette[regno>>1].red << 16) |
1092                                         (green << 8) |
1093                                        (rinfo->palette[regno>>1].blue));
1094                                 green = rinfo->palette[regno<<1].green;
1095                         }
1096                 }
1097
1098                 if (rinfo->depth != 16 || regno < 32) {
1099                         OUTREG(PALETTE_INDEX, pindex);
1100                         OUTREG(PALETTE_DATA, (red << 16) |
1101                                (green << 8) | blue);
1102                 }
1103         }
1104         if (regno < 16) {
1105                 u32 *pal = rinfo->info->pseudo_palette;
1106                 switch (rinfo->depth) {
1107                 case 15:
1108                         pal[regno] = (regno << 10) | (regno << 5) | regno;
1109                         break;
1110                 case 16:
1111                         pal[regno] = (regno << 11) | (regno << 5) | regno;
1112                         break;
1113                 case 24:
1114                         pal[regno] = (regno << 16) | (regno << 8) | regno;
1115                         break;
1116                 case 32:
1117                         i = (regno << 8) | regno;
1118                         pal[regno] = (i << 16) | i;
1119                         break;
1120                 }
1121         }
1122         return 0;
1123 }
1124
1125 static int radeonfb_setcolreg (unsigned regno, unsigned red, unsigned green,
1126                                unsigned blue, unsigned transp,
1127                                struct fb_info *info)
1128 {
1129         struct radeonfb_info *rinfo = info->par;
1130         u32 dac_cntl2, vclk_cntl = 0;
1131         int rc;
1132
1133         if (!rinfo->asleep) {
1134                 if (rinfo->is_mobility) {
1135                         vclk_cntl = INPLL(VCLK_ECP_CNTL);
1136                         OUTPLL(VCLK_ECP_CNTL,
1137                                vclk_cntl & ~PIXCLK_DAC_ALWAYS_ONb);
1138                 }
1139
1140                 /* Make sure we are on first palette */
1141                 if (rinfo->has_CRTC2) {
1142                         dac_cntl2 = INREG(DAC_CNTL2);
1143                         dac_cntl2 &= ~DAC2_PALETTE_ACCESS_CNTL;
1144                         OUTREG(DAC_CNTL2, dac_cntl2);
1145                 }
1146         }
1147
1148         rc = radeon_setcolreg (regno, red, green, blue, transp, rinfo);
1149
1150         if (!rinfo->asleep && rinfo->is_mobility)
1151                 OUTPLL(VCLK_ECP_CNTL, vclk_cntl);
1152
1153         return rc;
1154 }
1155
1156 static int radeonfb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1157 {
1158         struct radeonfb_info *rinfo = info->par;
1159         u16 *red, *green, *blue, *transp;
1160         u32 dac_cntl2, vclk_cntl = 0;
1161         int i, start, rc = 0;
1162
1163         if (!rinfo->asleep) {
1164                 if (rinfo->is_mobility) {
1165                         vclk_cntl = INPLL(VCLK_ECP_CNTL);
1166                         OUTPLL(VCLK_ECP_CNTL,
1167                                vclk_cntl & ~PIXCLK_DAC_ALWAYS_ONb);
1168                 }
1169
1170                 /* Make sure we are on first palette */
1171                 if (rinfo->has_CRTC2) {
1172                         dac_cntl2 = INREG(DAC_CNTL2);
1173                         dac_cntl2 &= ~DAC2_PALETTE_ACCESS_CNTL;
1174                         OUTREG(DAC_CNTL2, dac_cntl2);
1175                 }
1176         }
1177
1178         red = cmap->red;
1179         green = cmap->green;
1180         blue = cmap->blue;
1181         transp = cmap->transp;
1182         start = cmap->start;
1183
1184         for (i = 0; i < cmap->len; i++) {
1185                 u_int hred, hgreen, hblue, htransp = 0xffff;
1186
1187                 hred = *red++;
1188                 hgreen = *green++;
1189                 hblue = *blue++;
1190                 if (transp)
1191                         htransp = *transp++;
1192                 rc = radeon_setcolreg (start++, hred, hgreen, hblue, htransp,
1193                                        rinfo);
1194                 if (rc)
1195                         break;
1196         }
1197
1198         if (!rinfo->asleep && rinfo->is_mobility)
1199                 OUTPLL(VCLK_ECP_CNTL, vclk_cntl);
1200
1201         return rc;
1202 }
1203
1204 static void radeon_save_state (struct radeonfb_info *rinfo,
1205                                struct radeon_regs *save)
1206 {
1207         /* CRTC regs */
1208         save->crtc_gen_cntl = INREG(CRTC_GEN_CNTL);
1209         save->crtc_ext_cntl = INREG(CRTC_EXT_CNTL);
1210         save->crtc_more_cntl = INREG(CRTC_MORE_CNTL);
1211         save->dac_cntl = INREG(DAC_CNTL);
1212         save->crtc_h_total_disp = INREG(CRTC_H_TOTAL_DISP);
1213         save->crtc_h_sync_strt_wid = INREG(CRTC_H_SYNC_STRT_WID);
1214         save->crtc_v_total_disp = INREG(CRTC_V_TOTAL_DISP);
1215         save->crtc_v_sync_strt_wid = INREG(CRTC_V_SYNC_STRT_WID);
1216         save->crtc_pitch = INREG(CRTC_PITCH);
1217         save->surface_cntl = INREG(SURFACE_CNTL);
1218
1219         /* FP regs */
1220         save->fp_crtc_h_total_disp = INREG(FP_CRTC_H_TOTAL_DISP);
1221         save->fp_crtc_v_total_disp = INREG(FP_CRTC_V_TOTAL_DISP);
1222         save->fp_gen_cntl = INREG(FP_GEN_CNTL);
1223         save->fp_h_sync_strt_wid = INREG(FP_H_SYNC_STRT_WID);
1224         save->fp_horz_stretch = INREG(FP_HORZ_STRETCH);
1225         save->fp_v_sync_strt_wid = INREG(FP_V_SYNC_STRT_WID);
1226         save->fp_vert_stretch = INREG(FP_VERT_STRETCH);
1227         save->lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
1228         save->lvds_pll_cntl = INREG(LVDS_PLL_CNTL);
1229         save->tmds_crc = INREG(TMDS_CRC);
1230         save->tmds_transmitter_cntl = INREG(TMDS_TRANSMITTER_CNTL);
1231         save->vclk_ecp_cntl = INPLL(VCLK_ECP_CNTL);
1232
1233         /* PLL regs */
1234         save->clk_cntl_index = INREG(CLOCK_CNTL_INDEX) & ~0x3f;
1235         radeon_pll_errata_after_index(rinfo);
1236         save->ppll_div_3 = INPLL(PPLL_DIV_3);
1237         save->ppll_ref_div = INPLL(PPLL_REF_DIV);
1238 }
1239
1240
1241 static void radeon_write_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs *mode)
1242 {
1243         int i;
1244
1245         radeon_fifo_wait(20);
1246
1247         /* Workaround from XFree */
1248         if (rinfo->is_mobility) {
1249                 /* A temporal workaround for the occational blanking on certain laptop
1250                  * panels. This appears to related to the PLL divider registers
1251                  * (fail to lock?). It occurs even when all dividers are the same
1252                  * with their old settings. In this case we really don't need to
1253                  * fiddle with PLL registers. By doing this we can avoid the blanking
1254                  * problem with some panels.
1255                  */
1256                 if ((mode->ppll_ref_div == (INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK)) &&
1257                     (mode->ppll_div_3 == (INPLL(PPLL_DIV_3) &
1258                                           (PPLL_POST3_DIV_MASK | PPLL_FB3_DIV_MASK)))) {
1259                         /* We still have to force a switch to selected PPLL div thanks to
1260                          * an XFree86 driver bug which will switch it away in some cases
1261                          * even when using UseFDev */
1262                         OUTREGP(CLOCK_CNTL_INDEX,
1263                                 mode->clk_cntl_index & PPLL_DIV_SEL_MASK,
1264                                 ~PPLL_DIV_SEL_MASK);
1265                         radeon_pll_errata_after_index(rinfo);
1266                         radeon_pll_errata_after_data(rinfo);
1267                         return;
1268                 }
1269         }
1270
1271         /* Swich VCKL clock input to CPUCLK so it stays fed while PPLL updates*/
1272         OUTPLLP(VCLK_ECP_CNTL, VCLK_SRC_SEL_CPUCLK, ~VCLK_SRC_SEL_MASK);
1273
1274         /* Reset PPLL & enable atomic update */
1275         OUTPLLP(PPLL_CNTL,
1276                 PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN,
1277                 ~(PPLL_RESET | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
1278
1279         /* Switch to selected PPLL divider */
1280         OUTREGP(CLOCK_CNTL_INDEX,
1281                 mode->clk_cntl_index & PPLL_DIV_SEL_MASK,
1282                 ~PPLL_DIV_SEL_MASK);
1283         radeon_pll_errata_after_index(rinfo);
1284         radeon_pll_errata_after_data(rinfo);
1285
1286         /* Set PPLL ref. div */
1287         if (rinfo->family == CHIP_FAMILY_R300 ||
1288             rinfo->family == CHIP_FAMILY_RS300 ||
1289             rinfo->family == CHIP_FAMILY_R350 ||
1290             rinfo->family == CHIP_FAMILY_RV350 ||
1291             rinfo->family == CHIP_FAMILY_RV380 ) {
1292                 if (mode->ppll_ref_div & R300_PPLL_REF_DIV_ACC_MASK) {
1293                         /* When restoring console mode, use saved PPLL_REF_DIV
1294                          * setting.
1295                          */
1296                         OUTPLLP(PPLL_REF_DIV, mode->ppll_ref_div, 0);
1297                 } else {
1298                         /* R300 uses ref_div_acc field as real ref divider */
1299                         OUTPLLP(PPLL_REF_DIV,
1300                                 (mode->ppll_ref_div << R300_PPLL_REF_DIV_ACC_SHIFT),
1301                                 ~R300_PPLL_REF_DIV_ACC_MASK);
1302                 }
1303         } else
1304                 OUTPLLP(PPLL_REF_DIV, mode->ppll_ref_div, ~PPLL_REF_DIV_MASK);
1305
1306         /* Set PPLL divider 3 & post divider*/
1307         OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_FB3_DIV_MASK);
1308         OUTPLLP(PPLL_DIV_3, mode->ppll_div_3, ~PPLL_POST3_DIV_MASK);
1309
1310         /* Write update */
1311         while (INPLL(PPLL_REF_DIV) & PPLL_ATOMIC_UPDATE_R)
1312                 ;
1313         OUTPLLP(PPLL_REF_DIV, PPLL_ATOMIC_UPDATE_W, ~PPLL_ATOMIC_UPDATE_W);
1314
1315         /* Wait read update complete */
1316         /* FIXME: Certain revisions of R300 can't recover here.  Not sure of
1317            the cause yet, but this workaround will mask the problem for now.
1318            Other chips usually will pass at the very first test, so the
1319            workaround shouldn't have any effect on them. */
1320         for (i = 0; (i < 10000 && INPLL(PPLL_REF_DIV) & PPLL_ATOMIC_UPDATE_R); i++)
1321                 ;
1322
1323         OUTPLL(HTOTAL_CNTL, 0);
1324
1325         /* Clear reset & atomic update */
1326         OUTPLLP(PPLL_CNTL, 0,
1327                 ~(PPLL_RESET | PPLL_SLEEP | PPLL_ATOMIC_UPDATE_EN | PPLL_VGA_ATOMIC_UPDATE_EN));
1328
1329         /* We may want some locking ... oh well */
1330         radeon_msleep(5);
1331
1332         /* Switch back VCLK source to PPLL */
1333         OUTPLLP(VCLK_ECP_CNTL, VCLK_SRC_SEL_PPLLCLK, ~VCLK_SRC_SEL_MASK);
1334 }
1335
1336 /*
1337  * Timer function for delayed LVDS panel power up/down
1338  */
1339 static void radeon_lvds_timer_func(unsigned long data)
1340 {
1341         struct radeonfb_info *rinfo = (struct radeonfb_info *)data;
1342
1343         radeon_engine_idle();
1344
1345         OUTREG(LVDS_GEN_CNTL, rinfo->pending_lvds_gen_cntl);
1346 }
1347
1348 /*
1349  * Apply a video mode. This will apply the whole register set, including
1350  * the PLL registers, to the card
1351  */
1352 void radeon_write_mode (struct radeonfb_info *rinfo, struct radeon_regs *mode,
1353                         int regs_only)
1354 {
1355         int i;
1356         int primary_mon = PRIMARY_MONITOR(rinfo);
1357
1358         if (nomodeset)
1359                 return;
1360
1361         if (!regs_only)
1362                 radeon_screen_blank(rinfo, FB_BLANK_NORMAL, 0);
1363
1364         radeon_fifo_wait(31);
1365         for (i=0; i<10; i++)
1366                 OUTREG(common_regs[i].reg, common_regs[i].val);
1367
1368         /* Apply surface registers */
1369         for (i=0; i<8; i++) {
1370                 OUTREG(SURFACE0_LOWER_BOUND + 0x10*i, mode->surf_lower_bound[i]);
1371                 OUTREG(SURFACE0_UPPER_BOUND + 0x10*i, mode->surf_upper_bound[i]);
1372                 OUTREG(SURFACE0_INFO + 0x10*i, mode->surf_info[i]);
1373         }
1374
1375         OUTREG(CRTC_GEN_CNTL, mode->crtc_gen_cntl);
1376         OUTREGP(CRTC_EXT_CNTL, mode->crtc_ext_cntl,
1377                 ~(CRTC_HSYNC_DIS | CRTC_VSYNC_DIS | CRTC_DISPLAY_DIS));
1378         OUTREG(CRTC_MORE_CNTL, mode->crtc_more_cntl);
1379         OUTREGP(DAC_CNTL, mode->dac_cntl, DAC_RANGE_CNTL | DAC_BLANKING);
1380         OUTREG(CRTC_H_TOTAL_DISP, mode->crtc_h_total_disp);
1381         OUTREG(CRTC_H_SYNC_STRT_WID, mode->crtc_h_sync_strt_wid);
1382         OUTREG(CRTC_V_TOTAL_DISP, mode->crtc_v_total_disp);
1383         OUTREG(CRTC_V_SYNC_STRT_WID, mode->crtc_v_sync_strt_wid);
1384         OUTREG(CRTC_OFFSET, 0);
1385         OUTREG(CRTC_OFFSET_CNTL, 0);
1386         OUTREG(CRTC_PITCH, mode->crtc_pitch);
1387         OUTREG(SURFACE_CNTL, mode->surface_cntl);
1388
1389         radeon_write_pll_regs(rinfo, mode);
1390
1391         if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1392                 radeon_fifo_wait(10);
1393                 OUTREG(FP_CRTC_H_TOTAL_DISP, mode->fp_crtc_h_total_disp);
1394                 OUTREG(FP_CRTC_V_TOTAL_DISP, mode->fp_crtc_v_total_disp);
1395                 OUTREG(FP_H_SYNC_STRT_WID, mode->fp_h_sync_strt_wid);
1396                 OUTREG(FP_V_SYNC_STRT_WID, mode->fp_v_sync_strt_wid);
1397                 OUTREG(FP_HORZ_STRETCH, mode->fp_horz_stretch);
1398                 OUTREG(FP_VERT_STRETCH, mode->fp_vert_stretch);
1399                 OUTREG(FP_GEN_CNTL, mode->fp_gen_cntl);
1400                 OUTREG(TMDS_CRC, mode->tmds_crc);
1401                 OUTREG(TMDS_TRANSMITTER_CNTL, mode->tmds_transmitter_cntl);
1402         }
1403
1404         if (!regs_only)
1405                 radeon_screen_blank(rinfo, FB_BLANK_UNBLANK, 0);
1406
1407         radeon_fifo_wait(2);
1408         OUTPLL(VCLK_ECP_CNTL, mode->vclk_ecp_cntl);
1409
1410         return;
1411 }
1412
1413 /*
1414  * Calculate the PLL values for a given mode
1415  */
1416 static void radeon_calc_pll_regs(struct radeonfb_info *rinfo, struct radeon_regs *regs,
1417                                  unsigned long freq)
1418 {
1419         const struct {
1420                 int divider;
1421                 int bitvalue;
1422         } *post_div,
1423           post_divs[] = {
1424                 { 1,  0 },
1425                 { 2,  1 },
1426                 { 4,  2 },
1427                 { 8,  3 },
1428                 { 3,  4 },
1429                 { 16, 5 },
1430                 { 6,  6 },
1431                 { 12, 7 },
1432                 { 0,  0 },
1433         };
1434         int fb_div, pll_output_freq = 0;
1435         int uses_dvo = 0;
1436
1437         /* Check if the DVO port is enabled and sourced from the primary CRTC. I'm
1438          * not sure which model starts having FP2_GEN_CNTL, I assume anything more
1439          * recent than an r(v)100...
1440          */
1441 #if 1
1442         /* XXX I had reports of flicker happening with the cinema display
1443          * on TMDS1 that seem to be fixed if I also forbit odd dividers in
1444          * this case. This could just be a bandwidth calculation issue, I
1445          * haven't implemented the bandwidth code yet, but in the meantime,
1446          * forcing uses_dvo to 1 fixes it and shouln't have bad side effects,
1447          * I haven't seen a case were were absolutely needed an odd PLL
1448          * divider. I'll find a better fix once I have more infos on the
1449          * real cause of the problem.
1450          */
1451         while (rinfo->has_CRTC2) {
1452                 u32 fp2_gen_cntl = INREG(FP2_GEN_CNTL);
1453                 u32 disp_output_cntl;
1454                 int source;
1455
1456                 /* FP2 path not enabled */
1457                 if ((fp2_gen_cntl & FP2_ON) == 0)
1458                         break;
1459                 /* Not all chip revs have the same format for this register,
1460                  * extract the source selection
1461                  */
1462                 if (rinfo->family == CHIP_FAMILY_R200 ||
1463                     rinfo->family == CHIP_FAMILY_R300 ||
1464                     rinfo->family == CHIP_FAMILY_R350 ||
1465                     rinfo->family == CHIP_FAMILY_RV350) {
1466                         source = (fp2_gen_cntl >> 10) & 0x3;
1467                         /* sourced from transform unit, check for transform unit
1468                          * own source
1469                          */
1470                         if (source == 3) {
1471                                 disp_output_cntl = INREG(DISP_OUTPUT_CNTL);
1472                                 source = (disp_output_cntl >> 12) & 0x3;
1473                         }
1474                 } else
1475                         source = (fp2_gen_cntl >> 13) & 0x1;
1476                 /* sourced from CRTC2 -> exit */
1477                 if (source == 1)
1478                         break;
1479
1480                 /* so we end up on CRTC1, let's set uses_dvo to 1 now */
1481                 uses_dvo = 1;
1482                 break;
1483         }
1484 #else
1485         uses_dvo = 1;
1486 #endif
1487         if (freq > rinfo->pll.ppll_max)
1488                 freq = rinfo->pll.ppll_max;
1489         if (freq*12 < rinfo->pll.ppll_min)
1490                 freq = rinfo->pll.ppll_min / 12;
1491         RTRACE("freq = %lu, PLL min = %u, PLL max = %u\n",
1492                freq, rinfo->pll.ppll_min, rinfo->pll.ppll_max);
1493
1494         for (post_div = &post_divs[0]; post_div->divider; ++post_div) {
1495                 pll_output_freq = post_div->divider * freq;
1496                 /* If we output to the DVO port (external TMDS), we don't allow an
1497                  * odd PLL divider as those aren't supported on this path
1498                  */
1499                 if (uses_dvo && (post_div->divider & 1))
1500                         continue;
1501                 if (pll_output_freq >= rinfo->pll.ppll_min  &&
1502                     pll_output_freq <= rinfo->pll.ppll_max)
1503                         break;
1504         }
1505
1506         /* If we fall through the bottom, try the "default value"
1507            given by the terminal post_div->bitvalue */
1508         if ( !post_div->divider ) {
1509                 post_div = &post_divs[post_div->bitvalue];
1510                 pll_output_freq = post_div->divider * freq;
1511         }
1512         RTRACE("ref_div = %d, ref_clk = %d, output_freq = %d\n",
1513                rinfo->pll.ref_div, rinfo->pll.ref_clk,
1514                pll_output_freq);
1515
1516         /* If we fall through the bottom, try the "default value"
1517            given by the terminal post_div->bitvalue */
1518         if ( !post_div->divider ) {
1519                 post_div = &post_divs[post_div->bitvalue];
1520                 pll_output_freq = post_div->divider * freq;
1521         }
1522         RTRACE("ref_div = %d, ref_clk = %d, output_freq = %d\n",
1523                rinfo->pll.ref_div, rinfo->pll.ref_clk,
1524                pll_output_freq);
1525
1526         fb_div = round_div(rinfo->pll.ref_div*pll_output_freq,
1527                                   rinfo->pll.ref_clk);
1528         regs->ppll_ref_div = rinfo->pll.ref_div;
1529         regs->ppll_div_3 = fb_div | (post_div->bitvalue << 16);
1530
1531         RTRACE("post div = 0x%x\n", post_div->bitvalue);
1532         RTRACE("fb_div = 0x%x\n", fb_div);
1533         RTRACE("ppll_div_3 = 0x%x\n", regs->ppll_div_3);
1534 }
1535
1536 static int radeonfb_set_par(struct fb_info *info)
1537 {
1538         struct radeonfb_info *rinfo = info->par;
1539         struct fb_var_screeninfo *mode = &info->var;
1540         struct radeon_regs *newmode;
1541         int hTotal, vTotal, hSyncStart, hSyncEnd,
1542             hSyncPol, vSyncStart, vSyncEnd, vSyncPol, cSync;
1543         u8 hsync_adj_tab[] = {0, 0x12, 9, 9, 6, 5};
1544         u8 hsync_fudge_fp[] = {2, 2, 0, 0, 5, 5};
1545         u32 sync, h_sync_pol, v_sync_pol, dotClock, pixClock;
1546         int i, freq;
1547         int format = 0;
1548         int nopllcalc = 0;
1549         int hsync_start, hsync_fudge, bytpp, hsync_wid, vsync_wid;
1550         int primary_mon = PRIMARY_MONITOR(rinfo);
1551         int depth = var_to_depth(mode);
1552         int use_rmx = 0;
1553
1554         newmode = kmalloc(sizeof(struct radeon_regs), GFP_KERNEL);
1555         if (!newmode)
1556                 return -ENOMEM;
1557
1558         /* We always want engine to be idle on a mode switch, even
1559          * if we won't actually change the mode
1560          */
1561         radeon_engine_idle();
1562
1563         hSyncStart = mode->xres + mode->right_margin;
1564         hSyncEnd = hSyncStart + mode->hsync_len;
1565         hTotal = hSyncEnd + mode->left_margin;
1566
1567         vSyncStart = mode->yres + mode->lower_margin;
1568         vSyncEnd = vSyncStart + mode->vsync_len;
1569         vTotal = vSyncEnd + mode->upper_margin;
1570         pixClock = mode->pixclock;
1571
1572         sync = mode->sync;
1573         h_sync_pol = sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
1574         v_sync_pol = sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
1575
1576         if (primary_mon == MT_DFP || primary_mon == MT_LCD) {
1577                 if (rinfo->panel_info.xres < mode->xres)
1578                         mode->xres = rinfo->panel_info.xres;
1579                 if (rinfo->panel_info.yres < mode->yres)
1580                         mode->yres = rinfo->panel_info.yres;
1581
1582                 hTotal = mode->xres + rinfo->panel_info.hblank;
1583                 hSyncStart = mode->xres + rinfo->panel_info.hOver_plus;
1584                 hSyncEnd = hSyncStart + rinfo->panel_info.hSync_width;
1585
1586                 vTotal = mode->yres + rinfo->panel_info.vblank;
1587                 vSyncStart = mode->yres + rinfo->panel_info.vOver_plus;
1588                 vSyncEnd = vSyncStart + rinfo->panel_info.vSync_width;
1589
1590                 h_sync_pol = !rinfo->panel_info.hAct_high;
1591                 v_sync_pol = !rinfo->panel_info.vAct_high;
1592
1593                 pixClock = 100000000 / rinfo->panel_info.clock;
1594
1595                 if (rinfo->panel_info.use_bios_dividers) {
1596                         nopllcalc = 1;
1597                         newmode->ppll_div_3 = rinfo->panel_info.fbk_divider |
1598                                 (rinfo->panel_info.post_divider << 16);
1599                         newmode->ppll_ref_div = rinfo->panel_info.ref_divider;
1600                 }
1601         }
1602         dotClock = 1000000000 / pixClock;
1603         freq = dotClock / 10; /* x100 */
1604
1605         RTRACE("hStart = %d, hEnd = %d, hTotal = %d\n",
1606                 hSyncStart, hSyncEnd, hTotal);
1607         RTRACE("vStart = %d, vEnd = %d, vTotal = %d\n",
1608                 vSyncStart, vSyncEnd, vTotal);
1609
1610         hsync_wid = (hSyncEnd - hSyncStart) / 8;
1611         vsync_wid = vSyncEnd - vSyncStart;
1612         if (hsync_wid == 0)
1613                 hsync_wid = 1;
1614         else if (hsync_wid > 0x3f)      /* max */
1615                 hsync_wid = 0x3f;
1616
1617         if (vsync_wid == 0)
1618                 vsync_wid = 1;
1619         else if (vsync_wid > 0x1f)      /* max */
1620                 vsync_wid = 0x1f;
1621
1622         hSyncPol = mode->sync & FB_SYNC_HOR_HIGH_ACT ? 0 : 1;
1623         vSyncPol = mode->sync & FB_SYNC_VERT_HIGH_ACT ? 0 : 1;
1624
1625         cSync = mode->sync & FB_SYNC_COMP_HIGH_ACT ? (1 << 4) : 0;
1626
1627         format = radeon_get_dstbpp(depth);
1628         bytpp = mode->bits_per_pixel >> 3;
1629
1630         if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD))
1631                 hsync_fudge = hsync_fudge_fp[format-1];
1632         else
1633                 hsync_fudge = hsync_adj_tab[format-1];
1634
1635         hsync_start = hSyncStart - 8 + hsync_fudge;
1636
1637         newmode->crtc_gen_cntl = CRTC_EXT_DISP_EN | CRTC_EN |
1638                                 (format << 8);
1639
1640         /* Clear auto-center etc... */
1641         newmode->crtc_more_cntl = rinfo->init_state.crtc_more_cntl;
1642         newmode->crtc_more_cntl &= 0xfffffff0;
1643
1644         if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1645                 newmode->crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN;
1646                 if (mirror)
1647                         newmode->crtc_ext_cntl |= CRTC_CRT_ON;
1648
1649                 newmode->crtc_gen_cntl &= ~(CRTC_DBL_SCAN_EN |
1650                                            CRTC_INTERLACE_EN);
1651         } else {
1652                 newmode->crtc_ext_cntl = VGA_ATI_LINEAR | XCRT_CNT_EN |
1653                                         CRTC_CRT_ON;
1654         }
1655
1656         newmode->dac_cntl = /* INREG(DAC_CNTL) | */ DAC_MASK_ALL | DAC_VGA_ADR_EN |
1657                            DAC_8BIT_EN;
1658
1659         newmode->crtc_h_total_disp = ((((hTotal / 8) - 1) & 0x3ff) |
1660                                      (((mode->xres / 8) - 1) << 16));
1661
1662         newmode->crtc_h_sync_strt_wid = ((hsync_start & 0x1fff) |
1663                                         (hsync_wid << 16) | (h_sync_pol << 23));
1664
1665         newmode->crtc_v_total_disp = ((vTotal - 1) & 0xffff) |
1666                                     ((mode->yres - 1) << 16);
1667
1668         newmode->crtc_v_sync_strt_wid = (((vSyncStart - 1) & 0xfff) |
1669                                          (vsync_wid << 16) | (v_sync_pol  << 23));
1670
1671         if (!(info->flags & FBINFO_HWACCEL_DISABLED)) {
1672                 /* We first calculate the engine pitch */
1673                 rinfo->pitch = ((mode->xres_virtual * ((mode->bits_per_pixel + 1) / 8) + 0x3f)
1674                                 & ~(0x3f)) >> 6;
1675
1676                 /* Then, re-multiply it to get the CRTC pitch */
1677                 newmode->crtc_pitch = (rinfo->pitch << 3) / ((mode->bits_per_pixel + 1) / 8);
1678         } else
1679                 newmode->crtc_pitch = (mode->xres_virtual >> 3);
1680
1681         newmode->crtc_pitch |= (newmode->crtc_pitch << 16);
1682
1683         /*
1684          * It looks like recent chips have a problem with SURFACE_CNTL,
1685          * setting SURF_TRANSLATION_DIS completely disables the
1686          * swapper as well, so we leave it unset now.
1687          */
1688         newmode->surface_cntl = 0;
1689
1690 #if defined(__BIG_ENDIAN)
1691
1692         /* Setup swapping on both apertures, though we currently
1693          * only use aperture 0, enabling swapper on aperture 1
1694          * won't harm
1695          */
1696         switch (mode->bits_per_pixel) {
1697                 case 16:
1698                         newmode->surface_cntl |= NONSURF_AP0_SWP_16BPP;
1699                         newmode->surface_cntl |= NONSURF_AP1_SWP_16BPP;
1700                         break;
1701                 case 24:
1702                 case 32:
1703                         newmode->surface_cntl |= NONSURF_AP0_SWP_32BPP;
1704                         newmode->surface_cntl |= NONSURF_AP1_SWP_32BPP;
1705                         break;
1706         }
1707 #endif
1708
1709         /* Clear surface registers */
1710         for (i=0; i<8; i++) {
1711                 newmode->surf_lower_bound[i] = 0;
1712                 newmode->surf_upper_bound[i] = 0x1f;
1713                 newmode->surf_info[i] = 0;
1714         }
1715
1716         RTRACE("h_total_disp = 0x%x\t   hsync_strt_wid = 0x%x\n",
1717                 newmode->crtc_h_total_disp, newmode->crtc_h_sync_strt_wid);
1718         RTRACE("v_total_disp = 0x%x\t   vsync_strt_wid = 0x%x\n",
1719                 newmode->crtc_v_total_disp, newmode->crtc_v_sync_strt_wid);
1720
1721         rinfo->bpp = mode->bits_per_pixel;
1722         rinfo->depth = depth;
1723
1724         RTRACE("pixclock = %lu\n", (unsigned long)pixClock);
1725         RTRACE("freq = %lu\n", (unsigned long)freq);
1726
1727         /* We use PPLL_DIV_3 */
1728         newmode->clk_cntl_index = 0x300;
1729
1730         /* Calculate PPLL value if necessary */
1731         if (!nopllcalc)
1732                 radeon_calc_pll_regs(rinfo, newmode, freq);
1733
1734         newmode->vclk_ecp_cntl = rinfo->init_state.vclk_ecp_cntl;
1735
1736         if ((primary_mon == MT_DFP) || (primary_mon == MT_LCD)) {
1737                 unsigned int hRatio, vRatio;
1738
1739                 if (mode->xres > rinfo->panel_info.xres)
1740                         mode->xres = rinfo->panel_info.xres;
1741                 if (mode->yres > rinfo->panel_info.yres)
1742                         mode->yres = rinfo->panel_info.yres;
1743
1744                 newmode->fp_horz_stretch = (((rinfo->panel_info.xres / 8) - 1)
1745                                            << HORZ_PANEL_SHIFT);
1746                 newmode->fp_vert_stretch = ((rinfo->panel_info.yres - 1)
1747                                            << VERT_PANEL_SHIFT);
1748
1749                 if (mode->xres != rinfo->panel_info.xres) {
1750                         hRatio = round_div(mode->xres * HORZ_STRETCH_RATIO_MAX,
1751                                            rinfo->panel_info.xres);
1752                         newmode->fp_horz_stretch = (((((unsigned long)hRatio) & HORZ_STRETCH_RATIO_MASK)) |
1753                                                    (newmode->fp_horz_stretch &
1754                                                     (HORZ_PANEL_SIZE | HORZ_FP_LOOP_STRETCH |
1755                                                      HORZ_AUTO_RATIO_INC)));
1756                         newmode->fp_horz_stretch |= (HORZ_STRETCH_BLEND |
1757                                                     HORZ_STRETCH_ENABLE);
1758                         use_rmx = 1;
1759                 }
1760                 newmode->fp_horz_stretch &= ~HORZ_AUTO_RATIO;
1761
1762                 if (mode->yres != rinfo->panel_info.yres) {
1763                         vRatio = round_div(mode->yres * VERT_STRETCH_RATIO_MAX,
1764                                            rinfo->panel_info.yres);
1765                         newmode->fp_vert_stretch = (((((unsigned long)vRatio) & VERT_STRETCH_RATIO_MASK)) |
1766                                                    (newmode->fp_vert_stretch &
1767                                                    (VERT_PANEL_SIZE | VERT_STRETCH_RESERVED)));
1768                         newmode->fp_vert_stretch |= (VERT_STRETCH_BLEND |
1769                                                     VERT_STRETCH_ENABLE);
1770                         use_rmx = 1;
1771                 }
1772                 newmode->fp_vert_stretch &= ~VERT_AUTO_RATIO_EN;
1773
1774                 newmode->fp_gen_cntl = (rinfo->init_state.fp_gen_cntl & (u32)
1775                                        ~(FP_SEL_CRTC2 |
1776                                          FP_RMX_HVSYNC_CONTROL_EN |
1777                                          FP_DFP_SYNC_SEL |
1778                                          FP_CRT_SYNC_SEL |
1779                                          FP_CRTC_LOCK_8DOT |
1780                                          FP_USE_SHADOW_EN |
1781                                          FP_CRTC_USE_SHADOW_VEND |
1782                                          FP_CRT_SYNC_ALT));
1783
1784                 newmode->fp_gen_cntl |= (FP_CRTC_DONT_SHADOW_VPAR |
1785                                         FP_CRTC_DONT_SHADOW_HEND |
1786                                         FP_PANEL_FORMAT);
1787
1788                 if (IS_R300_VARIANT(rinfo) ||
1789                     (rinfo->family == CHIP_FAMILY_R200)) {
1790                         newmode->fp_gen_cntl &= ~R200_FP_SOURCE_SEL_MASK;
1791                         if (use_rmx)
1792                                 newmode->fp_gen_cntl |= R200_FP_SOURCE_SEL_RMX;
1793                         else
1794                                 newmode->fp_gen_cntl |= R200_FP_SOURCE_SEL_CRTC1;
1795                 } else
1796                         newmode->fp_gen_cntl |= FP_SEL_CRTC1;
1797
1798                 newmode->lvds_gen_cntl = rinfo->init_state.lvds_gen_cntl;
1799                 newmode->lvds_pll_cntl = rinfo->init_state.lvds_pll_cntl;
1800                 newmode->tmds_crc = rinfo->init_state.tmds_crc;
1801                 newmode->tmds_transmitter_cntl = rinfo->init_state.tmds_transmitter_cntl;
1802
1803                 if (primary_mon == MT_LCD) {
1804                         newmode->lvds_gen_cntl |= (LVDS_ON | LVDS_BLON);
1805                         newmode->fp_gen_cntl &= ~(FP_FPON | FP_TMDS_EN);
1806                 } else {
1807                         /* DFP */
1808                         newmode->fp_gen_cntl |= (FP_FPON | FP_TMDS_EN);
1809                         newmode->tmds_transmitter_cntl &= ~(TMDS_PLLRST);
1810                         /* TMDS_PLL_EN bit is reversed on RV (and mobility) chips */
1811                         if (IS_R300_VARIANT(rinfo) ||
1812                             (rinfo->family == CHIP_FAMILY_R200) || !rinfo->has_CRTC2)
1813                                 newmode->tmds_transmitter_cntl &= ~TMDS_PLL_EN;
1814                         else
1815                                 newmode->tmds_transmitter_cntl |= TMDS_PLL_EN;
1816                         newmode->crtc_ext_cntl &= ~CRTC_CRT_ON;
1817                 }
1818
1819                 newmode->fp_crtc_h_total_disp = (((rinfo->panel_info.hblank / 8) & 0x3ff) |
1820                                 (((mode->xres / 8) - 1) << 16));
1821                 newmode->fp_crtc_v_total_disp = (rinfo->panel_info.vblank & 0xffff) |
1822                                 ((mode->yres - 1) << 16);
1823                 newmode->fp_h_sync_strt_wid = ((rinfo->panel_info.hOver_plus & 0x1fff) |
1824                                 (hsync_wid << 16) | (h_sync_pol << 23));
1825                 newmode->fp_v_sync_strt_wid = ((rinfo->panel_info.vOver_plus & 0xfff) |
1826                                 (vsync_wid << 16) | (v_sync_pol  << 23));
1827         }
1828
1829         /* do it! */
1830         if (!rinfo->asleep) {
1831                 memcpy(&rinfo->state, newmode, sizeof(*newmode));
1832                 radeon_write_mode (rinfo, newmode, 0);
1833                 /* (re)initialize the engine */
1834                 if (!(info->flags & FBINFO_HWACCEL_DISABLED))
1835                         radeonfb_engine_init (rinfo);
1836         }
1837         /* Update fix */
1838         if (!(info->flags & FBINFO_HWACCEL_DISABLED))
1839                 info->fix.line_length = rinfo->pitch*64;
1840         else
1841                 info->fix.line_length = mode->xres_virtual
1842                         * ((mode->bits_per_pixel + 1) / 8);
1843         info->fix.visual = rinfo->depth == 8 ? FB_VISUAL_PSEUDOCOLOR
1844                 : FB_VISUAL_DIRECTCOLOR;
1845
1846 #ifdef CONFIG_BOOTX_TEXT
1847         /* Update debug text engine */
1848         btext_update_display(rinfo->fb_base_phys, mode->xres, mode->yres,
1849                              rinfo->depth, info->fix.line_length);
1850 #endif
1851
1852         kfree(newmode);
1853         return 0;
1854 }
1855
1856
1857 static struct fb_ops radeonfb_ops = {
1858         .owner                  = THIS_MODULE,
1859         .fb_check_var           = radeonfb_check_var,
1860         .fb_set_par             = radeonfb_set_par,
1861         .fb_setcolreg           = radeonfb_setcolreg,
1862         .fb_setcmap             = radeonfb_setcmap,
1863         .fb_pan_display         = radeonfb_pan_display,
1864         .fb_blank               = radeonfb_blank,
1865         .fb_ioctl               = radeonfb_ioctl,
1866         .fb_sync                = radeonfb_sync,
1867         .fb_fillrect            = radeonfb_fillrect,
1868         .fb_copyarea            = radeonfb_copyarea,
1869         .fb_imageblit           = radeonfb_imageblit,
1870 };
1871
1872
1873 static int __devinit radeon_set_fbinfo (struct radeonfb_info *rinfo)
1874 {
1875         struct fb_info *info = rinfo->info;
1876
1877         info->par = rinfo;
1878         info->pseudo_palette = rinfo->pseudo_palette;
1879         info->flags = FBINFO_DEFAULT
1880                     | FBINFO_HWACCEL_COPYAREA
1881                     | FBINFO_HWACCEL_FILLRECT
1882                     | FBINFO_HWACCEL_XPAN
1883                     | FBINFO_HWACCEL_YPAN;
1884         info->fbops = &radeonfb_ops;
1885         info->screen_base = rinfo->fb_base;
1886         info->screen_size = rinfo->mapped_vram;
1887         /* Fill fix common fields */
1888         strlcpy(info->fix.id, rinfo->name, sizeof(info->fix.id));
1889         info->fix.smem_start = rinfo->fb_base_phys;
1890         info->fix.smem_len = rinfo->video_ram;
1891         info->fix.type = FB_TYPE_PACKED_PIXELS;
1892         info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
1893         info->fix.xpanstep = 8;
1894         info->fix.ypanstep = 1;
1895         info->fix.ywrapstep = 0;
1896         info->fix.type_aux = 0;
1897         info->fix.mmio_start = rinfo->mmio_base_phys;
1898         info->fix.mmio_len = RADEON_REGSIZE;
1899         info->fix.accel = FB_ACCEL_ATI_RADEON;
1900
1901         fb_alloc_cmap(&info->cmap, 256, 0);
1902
1903         if (noaccel)
1904                 info->flags |= FBINFO_HWACCEL_DISABLED;
1905
1906         return 0;
1907 }
1908
1909 /*
1910  * This reconfigure the card's internal memory map. In theory, we'd like
1911  * to setup the card's memory at the same address as it's PCI bus address,
1912  * and the AGP aperture right after that so that system RAM on 32 bits
1913  * machines at least, is directly accessible. However, doing so would
1914  * conflict with the current XFree drivers...
1915  * Ultimately, I hope XFree, GATOS and ATI binary drivers will all agree
1916  * on the proper way to set this up and duplicate this here. In the meantime,
1917  * I put the card's memory at 0 in card space and AGP at some random high
1918  * local (0xe0000000 for now) that will be changed by XFree/DRI anyway
1919  */
1920 #ifdef CONFIG_PPC_OF
1921 #undef SET_MC_FB_FROM_APERTURE
1922 static void fixup_memory_mappings(struct radeonfb_info *rinfo)
1923 {
1924         u32 save_crtc_gen_cntl, save_crtc2_gen_cntl = 0;
1925         u32 save_crtc_ext_cntl;
1926         u32 aper_base, aper_size;
1927         u32 agp_base;
1928
1929         /* First, we disable display to avoid interfering */
1930         if (rinfo->has_CRTC2) {
1931                 save_crtc2_gen_cntl = INREG(CRTC2_GEN_CNTL);
1932                 OUTREG(CRTC2_GEN_CNTL, save_crtc2_gen_cntl | CRTC2_DISP_REQ_EN_B);
1933         }
1934         save_crtc_gen_cntl = INREG(CRTC_GEN_CNTL);
1935         save_crtc_ext_cntl = INREG(CRTC_EXT_CNTL);
1936
1937         OUTREG(CRTC_EXT_CNTL, save_crtc_ext_cntl | CRTC_DISPLAY_DIS);
1938         OUTREG(CRTC_GEN_CNTL, save_crtc_gen_cntl | CRTC_DISP_REQ_EN_B);
1939         mdelay(100);
1940
1941         aper_base = INREG(CONFIG_APER_0_BASE);
1942         aper_size = INREG(CONFIG_APER_SIZE);
1943
1944 #ifdef SET_MC_FB_FROM_APERTURE
1945         /* Set framebuffer to be at the same address as set in PCI BAR */
1946         OUTREG(MC_FB_LOCATION,
1947                 ((aper_base + aper_size - 1) & 0xffff0000) | (aper_base >> 16));
1948         rinfo->fb_local_base = aper_base;
1949 #else
1950         OUTREG(MC_FB_LOCATION, 0x7fff0000);
1951         rinfo->fb_local_base = 0;
1952 #endif
1953         agp_base = aper_base + aper_size;
1954         if (agp_base & 0xf0000000)
1955                 agp_base = (aper_base | 0x0fffffff) + 1;
1956
1957         /* Set AGP to be just after the framebuffer on a 256Mb boundary. This
1958          * assumes the FB isn't mapped to 0xf0000000 or above, but this is
1959          * always the case on PPCs afaik.
1960          */
1961 #ifdef SET_MC_FB_FROM_APERTURE
1962         OUTREG(MC_AGP_LOCATION, 0xffff0000 | (agp_base >> 16));
1963 #else
1964         OUTREG(MC_AGP_LOCATION, 0xffffe000);
1965 #endif
1966
1967         /* Fixup the display base addresses & engine offsets while we
1968          * are at it as well
1969          */
1970 #ifdef SET_MC_FB_FROM_APERTURE
1971         OUTREG(DISPLAY_BASE_ADDR, aper_base);
1972         if (rinfo->has_CRTC2)
1973                 OUTREG(CRTC2_DISPLAY_BASE_ADDR, aper_base);
1974         OUTREG(OV0_BASE_ADDR, aper_base);
1975 #else
1976         OUTREG(DISPLAY_BASE_ADDR, 0);
1977         if (rinfo->has_CRTC2)
1978                 OUTREG(CRTC2_DISPLAY_BASE_ADDR, 0);
1979         OUTREG(OV0_BASE_ADDR, 0);
1980 #endif
1981         mdelay(100);
1982
1983         /* Restore display settings */
1984         OUTREG(CRTC_GEN_CNTL, save_crtc_gen_cntl);
1985         OUTREG(CRTC_EXT_CNTL, save_crtc_ext_cntl);
1986         if (rinfo->has_CRTC2)
1987                 OUTREG(CRTC2_GEN_CNTL, save_crtc2_gen_cntl);
1988
1989         RTRACE("aper_base: %08x MC_FB_LOC to: %08x, MC_AGP_LOC to: %08x\n",
1990                 aper_base,
1991                 ((aper_base + aper_size - 1) & 0xffff0000) | (aper_base >> 16),
1992                 0xffff0000 | (agp_base >> 16));
1993 }
1994 #endif /* CONFIG_PPC_OF */
1995
1996
1997 static void radeon_identify_vram(struct radeonfb_info *rinfo)
1998 {
1999         u32 tmp;
2000
2001         /* framebuffer size */
2002         if ((rinfo->family == CHIP_FAMILY_RS100) ||
2003             (rinfo->family == CHIP_FAMILY_RS200) ||
2004             (rinfo->family == CHIP_FAMILY_RS300) ||
2005             (rinfo->family == CHIP_FAMILY_RC410) ||
2006             (rinfo->family == CHIP_FAMILY_RS480) ) {
2007           u32 tom = INREG(NB_TOM);
2008           tmp = ((((tom >> 16) - (tom & 0xffff) + 1) << 6) * 1024);
2009
2010                 radeon_fifo_wait(6);
2011           OUTREG(MC_FB_LOCATION, tom);
2012           OUTREG(DISPLAY_BASE_ADDR, (tom & 0xffff) << 16);
2013           OUTREG(CRTC2_DISPLAY_BASE_ADDR, (tom & 0xffff) << 16);
2014           OUTREG(OV0_BASE_ADDR, (tom & 0xffff) << 16);
2015
2016           /* This is supposed to fix the crtc2 noise problem. */
2017           OUTREG(GRPH2_BUFFER_CNTL, INREG(GRPH2_BUFFER_CNTL) & ~0x7f0000);
2018
2019           if ((rinfo->family == CHIP_FAMILY_RS100) ||
2020               (rinfo->family == CHIP_FAMILY_RS200)) {
2021              /* This is to workaround the asic bug for RMX, some versions
2022                 of BIOS dosen't have this register initialized correctly.
2023              */
2024              OUTREGP(CRTC_MORE_CNTL, CRTC_H_CUTOFF_ACTIVE_EN,
2025                      ~CRTC_H_CUTOFF_ACTIVE_EN);
2026           }
2027         } else {
2028           tmp = INREG(CONFIG_MEMSIZE);
2029         }
2030
2031         /* mem size is bits [28:0], mask off the rest */
2032         rinfo->video_ram = tmp & CONFIG_MEMSIZE_MASK;
2033
2034         /*
2035          * Hack to get around some busted production M6's
2036          * reporting no ram
2037          */
2038         if (rinfo->video_ram == 0) {
2039                 switch (rinfo->pdev->device) {
2040                 case PCI_CHIP_RADEON_LY:
2041                 case PCI_CHIP_RADEON_LZ:
2042                         rinfo->video_ram = 8192 * 1024;
2043                         break;
2044                 default:
2045                         break;
2046                 }
2047         }
2048
2049
2050         /*
2051          * Now try to identify VRAM type
2052          */
2053         if (rinfo->is_IGP || (rinfo->family >= CHIP_FAMILY_R300) ||
2054             (INREG(MEM_SDRAM_MODE_REG) & (1<<30)))
2055                 rinfo->vram_ddr = 1;
2056         else
2057                 rinfo->vram_ddr = 0;
2058
2059         tmp = INREG(MEM_CNTL);
2060         if (IS_R300_VARIANT(rinfo)) {
2061                 tmp &=  R300_MEM_NUM_CHANNELS_MASK;
2062                 switch (tmp) {
2063                 case 0:  rinfo->vram_width = 64; break;
2064                 case 1:  rinfo->vram_width = 128; break;
2065                 case 2:  rinfo->vram_width = 256; break;
2066                 default: rinfo->vram_width = 128; break;
2067                 }
2068         } else if ((rinfo->family == CHIP_FAMILY_RV100) ||
2069                    (rinfo->family == CHIP_FAMILY_RS100) ||
2070                    (rinfo->family == CHIP_FAMILY_RS200)){
2071                 if (tmp & RV100_MEM_HALF_MODE)
2072                         rinfo->vram_width = 32;
2073                 else
2074                         rinfo->vram_width = 64;
2075         } else {
2076                 if (tmp & MEM_NUM_CHANNELS_MASK)
2077                         rinfo->vram_width = 128;
2078                 else
2079                         rinfo->vram_width = 64;
2080         }
2081
2082         /* This may not be correct, as some cards can have half of channel disabled
2083          * ToDo: identify these cases
2084          */
2085
2086         RTRACE("radeonfb (%s): Found %ldk of %s %d bits wide videoram\n",
2087                pci_name(rinfo->pdev),
2088                rinfo->video_ram / 1024,
2089                rinfo->vram_ddr ? "DDR" : "SDRAM",
2090                rinfo->vram_width);
2091 }
2092
2093 /*
2094  * Sysfs
2095  */
2096
2097 static ssize_t radeon_show_one_edid(char *buf, loff_t off, size_t count, const u8 *edid)
2098 {
2099         if (off > EDID_LENGTH)
2100                 return 0;
2101
2102         if (off + count > EDID_LENGTH)
2103                 count = EDID_LENGTH - off;
2104
2105         memcpy(buf, edid + off, count);
2106
2107         return count;
2108 }
2109
2110
2111 static ssize_t radeon_show_edid1(struct kobject *kobj,
2112                                  struct bin_attribute *bin_attr,
2113                                  char *buf, loff_t off, size_t count)
2114 {
2115         struct device *dev = container_of(kobj, struct device, kobj);
2116         struct pci_dev *pdev = to_pci_dev(dev);
2117         struct fb_info *info = pci_get_drvdata(pdev);
2118         struct radeonfb_info *rinfo = info->par;
2119
2120         return radeon_show_one_edid(buf, off, count, rinfo->mon1_EDID);
2121 }
2122
2123
2124 static ssize_t radeon_show_edid2(struct kobject *kobj,
2125                                  struct bin_attribute *bin_attr,
2126                                  char *buf, loff_t off, size_t count)
2127 {
2128         struct device *dev = container_of(kobj, struct device, kobj);
2129         struct pci_dev *pdev = to_pci_dev(dev);
2130         struct fb_info *info = pci_get_drvdata(pdev);
2131         struct radeonfb_info *rinfo = info->par;
2132
2133         return radeon_show_one_edid(buf, off, count, rinfo->mon2_EDID);
2134 }
2135
2136 static struct bin_attribute edid1_attr = {
2137         .attr   = {
2138                 .name   = "edid1",
2139                 .mode   = 0444,
2140         },
2141         .size   = EDID_LENGTH,
2142         .read   = radeon_show_edid1,
2143 };
2144
2145 static struct bin_attribute edid2_attr = {
2146         .attr   = {
2147                 .name   = "edid2",
2148                 .mode   = 0444,
2149         },
2150         .size   = EDID_LENGTH,
2151         .read   = radeon_show_edid2,
2152 };
2153
2154
2155 static int __devinit radeonfb_pci_register (struct pci_dev *pdev,
2156                                   const struct pci_device_id *ent)
2157 {
2158         struct fb_info *info;
2159         struct radeonfb_info *rinfo;
2160         int ret;
2161
2162         RTRACE("radeonfb_pci_register BEGIN\n");
2163
2164         /* Enable device in PCI config */
2165         ret = pci_enable_device(pdev);
2166         if (ret < 0) {
2167                 printk(KERN_ERR "radeonfb (%s): Cannot enable PCI device\n",
2168                        pci_name(pdev));
2169                 goto err_out;
2170         }
2171
2172         info = framebuffer_alloc(sizeof(struct radeonfb_info), &pdev->dev);
2173         if (!info) {
2174                 printk (KERN_ERR "radeonfb (%s): could not allocate memory\n",
2175                         pci_name(pdev));
2176                 ret = -ENOMEM;
2177                 goto err_disable;
2178         }
2179         rinfo = info->par;
2180         rinfo->info = info;
2181         rinfo->pdev = pdev;
2182
2183         spin_lock_init(&rinfo->reg_lock);
2184         init_timer(&rinfo->lvds_timer);
2185         rinfo->lvds_timer.function = radeon_lvds_timer_func;
2186         rinfo->lvds_timer.data = (unsigned long)rinfo;
2187
2188         strcpy(rinfo->name, "ATI Radeon XX ");
2189         rinfo->name[11] = ent->device >> 8;
2190         rinfo->name[12] = ent->device & 0xFF;
2191         rinfo->family = ent->driver_data & CHIP_FAMILY_MASK;
2192         rinfo->chipset = pdev->device;
2193         rinfo->has_CRTC2 = (ent->driver_data & CHIP_HAS_CRTC2) != 0;
2194         rinfo->is_mobility = (ent->driver_data & CHIP_IS_MOBILITY) != 0;
2195         rinfo->is_IGP = (ent->driver_data & CHIP_IS_IGP) != 0;
2196
2197         /* Set base addrs */
2198         rinfo->fb_base_phys = pci_resource_start (pdev, 0);
2199         rinfo->mmio_base_phys = pci_resource_start (pdev, 2);
2200
2201         /* request the mem regions */
2202         ret = pci_request_region(pdev, 0, "radeonfb framebuffer");
2203         if (ret < 0) {
2204                 printk( KERN_ERR "radeonfb (%s): cannot request region 0.\n",
2205                         pci_name(rinfo->pdev));
2206                 goto err_release_fb;
2207         }
2208
2209         ret = pci_request_region(pdev, 2, "radeonfb mmio");
2210         if (ret < 0) {
2211                 printk( KERN_ERR "radeonfb (%s): cannot request region 2.\n",
2212                         pci_name(rinfo->pdev));
2213                 goto err_release_pci0;
2214         }
2215
2216         /* map the regions */
2217         rinfo->mmio_base = ioremap(rinfo->mmio_base_phys, RADEON_REGSIZE);
2218         if (!rinfo->mmio_base) {
2219                 printk(KERN_ERR "radeonfb (%s): cannot map MMIO\n",
2220                        pci_name(rinfo->pdev));
2221                 ret = -EIO;
2222                 goto err_release_pci2;
2223         }
2224
2225         rinfo->fb_local_base = INREG(MC_FB_LOCATION) << 16;
2226
2227         /*
2228          * Check for errata
2229          */
2230         rinfo->errata = 0;
2231         if (rinfo->family == CHIP_FAMILY_R300 &&
2232             (INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK)
2233             == CFG_ATI_REV_A11)
2234                 rinfo->errata |= CHIP_ERRATA_R300_CG;
2235
2236         if (rinfo->family == CHIP_FAMILY_RV200 ||
2237             rinfo->family == CHIP_FAMILY_RS200)
2238                 rinfo->errata |= CHIP_ERRATA_PLL_DUMMYREADS;
2239
2240         if (rinfo->family == CHIP_FAMILY_RV100 ||
2241             rinfo->family == CHIP_FAMILY_RS100 ||
2242             rinfo->family == CHIP_FAMILY_RS200)
2243                 rinfo->errata |= CHIP_ERRATA_PLL_DELAY;
2244
2245 #if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
2246         /* On PPC, we obtain the OF device-node pointer to the firmware
2247          * data for this chip
2248          */
2249         rinfo->of_node = pci_device_to_OF_node(pdev);
2250         if (rinfo->of_node == NULL)
2251                 printk(KERN_WARNING "radeonfb (%s): Cannot match card to OF node !\n",
2252                        pci_name(rinfo->pdev));
2253
2254 #endif /* CONFIG_PPC_OF || CONFIG_SPARC */
2255 #ifdef CONFIG_PPC_OF
2256         /* On PPC, the firmware sets up a memory mapping that tends
2257          * to cause lockups when enabling the engine. We reconfigure
2258          * the card internal memory mappings properly
2259          */
2260         fixup_memory_mappings(rinfo);
2261 #endif /* CONFIG_PPC_OF */
2262
2263         /* Get VRAM size and type */
2264         radeon_identify_vram(rinfo);
2265
2266         rinfo->mapped_vram = min_t(unsigned long, MAX_MAPPED_VRAM, rinfo->video_ram);
2267
2268         do {
2269                 rinfo->fb_base = ioremap (rinfo->fb_base_phys,
2270                                           rinfo->mapped_vram);
2271         } while (   rinfo->fb_base == 0 &&
2272                   ((rinfo->mapped_vram /=2) >= MIN_MAPPED_VRAM) );
2273
2274         if (rinfo->fb_base == NULL) {
2275                 printk (KERN_ERR "radeonfb (%s): cannot map FB\n",
2276                         pci_name(rinfo->pdev));
2277                 ret = -EIO;
2278                 goto err_unmap_rom;
2279         }
2280
2281         RTRACE("radeonfb (%s): mapped %ldk videoram\n", pci_name(rinfo->pdev),
2282                rinfo->mapped_vram/1024);
2283
2284         /*
2285          * Map the BIOS ROM if any and retrieve PLL parameters from
2286          * the BIOS. We skip that on mobility chips as the real panel
2287          * values we need aren't in the ROM but in the BIOS image in
2288          * memory. This is definitely not the best meacnism though,
2289          * we really need the arch code to tell us which is the "primary"
2290          * video adapter to use the memory image (or better, the arch
2291          * should provide us a copy of the BIOS image to shield us from
2292          * archs who would store that elsewhere and/or could initialize
2293          * more than one adapter during boot).
2294          */
2295         if (!rinfo->is_mobility)
2296                 radeon_map_ROM(rinfo, pdev);
2297
2298         /*
2299          * On x86, the primary display on laptop may have it's BIOS
2300          * ROM elsewhere, try to locate it at the legacy memory hole.
2301          * We probably need to make sure this is the primary display,
2302          * but that is difficult without some arch support.
2303          */
2304 #ifdef CONFIG_X86
2305         if (rinfo->bios_seg == NULL)
2306                 radeon_find_mem_vbios(rinfo);
2307 #endif
2308
2309         /* If both above failed, try the BIOS ROM again for mobility
2310          * chips
2311          */
2312         if (rinfo->bios_seg == NULL && rinfo->is_mobility)
2313                 radeon_map_ROM(rinfo, pdev);
2314
2315         /* Get informations about the board's PLL */
2316         radeon_get_pllinfo(rinfo);
2317
2318 #ifdef CONFIG_FB_RADEON_I2C
2319         /* Register I2C bus */
2320         radeon_create_i2c_busses(rinfo);
2321 #endif
2322
2323         /* set all the vital stuff */
2324         radeon_set_fbinfo (rinfo);
2325
2326         /* Probe screen types */
2327         radeon_probe_screens(rinfo, monitor_layout, ignore_edid);
2328
2329         /* Build mode list, check out panel native model */
2330         radeon_check_modes(rinfo, mode_option);
2331
2332         /* Register some sysfs stuff (should be done better) */
2333         if (rinfo->mon1_EDID)
2334                 sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
2335         if (rinfo->mon2_EDID)
2336                 sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
2337
2338         /* save current mode regs before we switch into the new one
2339          * so we can restore this upon __exit
2340          */
2341         radeon_save_state (rinfo, &rinfo->init_state);
2342         memcpy(&rinfo->state, &rinfo->init_state, sizeof(struct radeon_regs));
2343
2344         /* Setup Power Management capabilities */
2345         if (default_dynclk < -1) {
2346                 /* -2 is special: means  ON on mobility chips and do not
2347                  * change on others
2348                  */
2349                 radeonfb_pm_init(rinfo, rinfo->is_mobility ? 1 : -1, ignore_devlist, force_sleep);
2350         } else
2351                 radeonfb_pm_init(rinfo, default_dynclk, ignore_devlist, force_sleep);
2352
2353         pci_set_drvdata(pdev, info);
2354
2355         /* Register with fbdev layer */
2356         ret = register_framebuffer(info);
2357         if (ret < 0) {
2358                 printk (KERN_ERR "radeonfb (%s): could not register framebuffer\n",
2359                         pci_name(rinfo->pdev));
2360                 goto err_unmap_fb;
2361         }
2362
2363 #ifdef CONFIG_MTRR
2364         rinfo->mtrr_hdl = nomtrr ? -1 : mtrr_add(rinfo->fb_base_phys,
2365                                                  rinfo->video_ram,
2366                                                  MTRR_TYPE_WRCOMB, 1);
2367 #endif
2368
2369         if (backlight)
2370                 radeonfb_bl_init(rinfo);
2371
2372         printk ("radeonfb (%s): %s\n", pci_name(rinfo->pdev), rinfo->name);
2373
2374         if (rinfo->bios_seg)
2375                 radeon_unmap_ROM(rinfo, pdev);
2376         RTRACE("radeonfb_pci_register END\n");
2377
2378         return 0;
2379 err_unmap_fb:
2380         iounmap(rinfo->fb_base);
2381 err_unmap_rom:
2382         kfree(rinfo->mon1_EDID);
2383         kfree(rinfo->mon2_EDID);
2384         if (rinfo->mon1_modedb)
2385                 fb_destroy_modedb(rinfo->mon1_modedb);
2386         fb_dealloc_cmap(&info->cmap);
2387 #ifdef CONFIG_FB_RADEON_I2C
2388         radeon_delete_i2c_busses(rinfo);
2389 #endif
2390         if (rinfo->bios_seg)
2391                 radeon_unmap_ROM(rinfo, pdev);
2392         iounmap(rinfo->mmio_base);
2393 err_release_pci2:
2394         pci_release_region(pdev, 2);
2395 err_release_pci0:
2396         pci_release_region(pdev, 0);
2397 err_release_fb:
2398         framebuffer_release(info);
2399 err_disable:
2400 err_out:
2401         return ret;
2402 }
2403
2404
2405
2406 static void __devexit radeonfb_pci_unregister (struct pci_dev *pdev)
2407 {
2408         struct fb_info *info = pci_get_drvdata(pdev);
2409         struct radeonfb_info *rinfo = info->par;
2410
2411         if (!rinfo)
2412                 return;
2413
2414         radeonfb_pm_exit(rinfo);
2415
2416         if (rinfo->mon1_EDID)
2417                 sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
2418         if (rinfo->mon2_EDID)
2419                 sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
2420
2421 #if 0
2422         /* restore original state
2423          *
2424          * Doesn't quite work yet, I suspect if we come from a legacy
2425          * VGA mode (or worse, text mode), we need to do some VGA black
2426          * magic here that I know nothing about. --BenH
2427          */
2428         radeon_write_mode (rinfo, &rinfo->init_state, 1);
2429  #endif
2430
2431         del_timer_sync(&rinfo->lvds_timer);
2432
2433 #ifdef CONFIG_MTRR
2434         if (rinfo->mtrr_hdl >= 0)
2435                 mtrr_del(rinfo->mtrr_hdl, 0, 0);
2436 #endif
2437
2438         unregister_framebuffer(info);
2439
2440         radeonfb_bl_exit(rinfo);
2441
2442         iounmap(rinfo->mmio_base);
2443         iounmap(rinfo->fb_base);
2444
2445         pci_release_region(pdev, 2);
2446         pci_release_region(pdev, 0);
2447
2448         kfree(rinfo->mon1_EDID);
2449         kfree(rinfo->mon2_EDID);
2450         if (rinfo->mon1_modedb)
2451                 fb_destroy_modedb(rinfo->mon1_modedb);
2452 #ifdef CONFIG_FB_RADEON_I2C
2453         radeon_delete_i2c_busses(rinfo);
2454 #endif
2455         fb_dealloc_cmap(&info->cmap);
2456         framebuffer_release(info);
2457 }
2458
2459
2460 static struct pci_driver radeonfb_driver = {
2461         .name           = "radeonfb",
2462         .id_table       = radeonfb_pci_table,
2463         .probe          = radeonfb_pci_register,
2464         .remove         = __devexit_p(radeonfb_pci_unregister),
2465 #ifdef CONFIG_PM
2466         .suspend        = radeonfb_pci_suspend,
2467         .resume         = radeonfb_pci_resume,
2468 #endif /* CONFIG_PM */
2469 };
2470
2471 #ifndef MODULE
2472 static int __init radeonfb_setup (char *options)
2473 {
2474         char *this_opt;
2475
2476         if (!options || !*options)
2477                 return 0;
2478
2479         while ((this_opt = strsep (&options, ",")) != NULL) {
2480                 if (!*this_opt)
2481                         continue;
2482
2483                 if (!strncmp(this_opt, "noaccel", 7)) {
2484                         noaccel = 1;
2485                 } else if (!strncmp(this_opt, "mirror", 6)) {
2486                         mirror = 1;
2487                 } else if (!strncmp(this_opt, "force_dfp", 9)) {
2488                         force_dfp = 1;
2489                 } else if (!strncmp(this_opt, "panel_yres:", 11)) {
2490                         panel_yres = simple_strtoul((this_opt+11), NULL, 0);
2491                 } else if (!strncmp(this_opt, "backlight:", 10)) {
2492                         backlight = simple_strtoul(this_opt+10, NULL, 0);
2493 #ifdef CONFIG_MTRR
2494                 } else if (!strncmp(this_opt, "nomtrr", 6)) {
2495                         nomtrr = 1;
2496 #endif
2497                 } else if (!strncmp(this_opt, "nomodeset", 9)) {
2498                         nomodeset = 1;
2499                 } else if (!strncmp(this_opt, "force_measure_pll", 17)) {
2500                         force_measure_pll = 1;
2501                 } else if (!strncmp(this_opt, "ignore_edid", 11)) {
2502                         ignore_edid = 1;
2503 #if defined(CONFIG_PM) && defined(CONFIG_X86)
2504                 } else if (!strncmp(this_opt, "force_sleep", 11)) {
2505                         force_sleep = 1;
2506                 } else if (!strncmp(this_opt, "ignore_devlist", 14)) {
2507                         ignore_devlist = 1;
2508 #endif
2509                 } else
2510                         mode_option = this_opt;
2511         }
2512         return 0;
2513 }
2514 #endif  /*  MODULE  */
2515
2516 static int __init radeonfb_init (void)
2517 {
2518 #ifndef MODULE
2519         char *option = NULL;
2520
2521         if (fb_get_options("radeonfb", &option))
2522                 return -ENODEV;
2523         radeonfb_setup(option);
2524 #endif
2525         return pci_register_driver (&radeonfb_driver);
2526 }
2527
2528
2529 static void __exit radeonfb_exit (void)
2530 {
2531         pci_unregister_driver (&radeonfb_driver);
2532 }
2533
2534 module_init(radeonfb_init);
2535 module_exit(radeonfb_exit);
2536
2537 MODULE_AUTHOR("Ani Joshi");
2538 MODULE_DESCRIPTION("framebuffer driver for ATI Radeon chipset");
2539 MODULE_LICENSE("GPL");
2540 module_param(noaccel, bool, 0);
2541 module_param(default_dynclk, int, 0);
2542 MODULE_PARM_DESC(default_dynclk, "int: -2=enable on mobility only,-1=do not change,0=off,1=on");
2543 MODULE_PARM_DESC(noaccel, "bool: disable acceleration");
2544 module_param(nomodeset, bool, 0);
2545 MODULE_PARM_DESC(nomodeset, "bool: disable actual setting of video mode");
2546 module_param(mirror, bool, 0);
2547 MODULE_PARM_DESC(mirror, "bool: mirror the display to both monitors");
2548 module_param(force_dfp, bool, 0);
2549 MODULE_PARM_DESC(force_dfp, "bool: force display to dfp");
2550 module_param(ignore_edid, bool, 0);
2551 MODULE_PARM_DESC(ignore_edid, "bool: Ignore EDID data when doing DDC probe");
2552 module_param(monitor_layout, charp, 0);
2553 MODULE_PARM_DESC(monitor_layout, "Specify monitor mapping (like XFree86)");
2554 module_param(force_measure_pll, bool, 0);
2555 MODULE_PARM_DESC(force_measure_pll, "Force measurement of PLL (debug)");
2556 #ifdef CONFIG_MTRR
2557 module_param(nomtrr, bool, 0);
2558 MODULE_PARM_DESC(nomtrr, "bool: disable use of MTRR registers");
2559 #endif
2560 module_param(panel_yres, int, 0);
2561 MODULE_PARM_DESC(panel_yres, "int: set panel yres");
2562 module_param(mode_option, charp, 0);
2563 MODULE_PARM_DESC(mode_option, "Specify resolution as \"<xres>x<yres>[-<bpp>][@<refresh>]\" ");
2564 #if defined(CONFIG_PM) && defined(CONFIG_X86)
2565 module_param(force_sleep, bool, 0);
2566 MODULE_PARM_DESC(force_sleep, "bool: force D2 sleep mode on all hardware");
2567 module_param(ignore_devlist, bool, 0);
2568 MODULE_PARM_DESC(ignore_devlist, "bool: ignore workarounds for bugs in specific laptops");
2569 #endif