drivers/video/aty/radeon_base.c

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