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