SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/video/aty/radeon_pm.c

   1 /*
   2  *      drivers/video/aty/radeon_pm.c
   3  *
   4  *      Copyright 2003,2004 Ben. Herrenschmidt <benh@kernel.crashing.org>
   5  *      Copyright 2004 Paul Mackerras <paulus@samba.org>
   6  *
   7  *      This is the power management code for ATI radeon chipsets. It contains
   8  *      some dynamic clock PM enable/disable code similar to what X.org does,
   9  *      some D2-state (APM-style) sleep/wakeup code for use on some PowerMacs,
  10  *      and the necessary bits to re-initialize from scratch a few chips found
  11  *      on PowerMacs as well. The later could be extended to more platforms
  12  *      provided the memory controller configuration code be made more generic,
  13  *      and you can get the proper mode register commands for your RAMs.
  14  *      Those things may be found in the BIOS image...
  15  */
  16
  17 #include "radeonfb.h"
  18
  19 #include <linux/console.h>
  20 #include <linux/agp_backend.h>
  21
  22 #ifdef CONFIG_PPC_PMAC
  23 #include <asm/machdep.h>
  24 #include <asm/prom.h>
  25 #include <asm/pmac_feature.h>
  26 #endif
  27
  28 #include "ati_ids.h"
  29
  30 static void radeon_pm_disable_dynamic_mode(struct radeonfb_info *rinfo)
  31 {
  32         u32 tmp;
  33
  34         /* RV100 */
  35         if ((rinfo->family == CHIP_FAMILY_RV100) && (!rinfo->is_mobility)) {
  36                 if (rinfo->has_CRTC2) {
  37                         tmp = INPLL(pllSCLK_CNTL);
  38                         tmp &= ~SCLK_CNTL__DYN_STOP_LAT_MASK;
  39                         tmp |= SCLK_CNTL__CP_MAX_DYN_STOP_LAT | SCLK_CNTL__FORCEON_MASK;
  40                         OUTPLL(pllSCLK_CNTL, tmp);
  41                 }
  42                 tmp = INPLL(pllMCLK_CNTL);
  43                 tmp |= (MCLK_CNTL__FORCE_MCLKA |
  44                         MCLK_CNTL__FORCE_MCLKB |
  45                         MCLK_CNTL__FORCE_YCLKA |
  46                         MCLK_CNTL__FORCE_YCLKB |
  47                         MCLK_CNTL__FORCE_AIC |
  48                         MCLK_CNTL__FORCE_MC);
  49                 OUTPLL(pllMCLK_CNTL, tmp);
  50                 return;
  51         }
  52         /* R100 */
  53         if (!rinfo->has_CRTC2) {
  54                 tmp = INPLL(pllSCLK_CNTL);
  55                 tmp |= (SCLK_CNTL__FORCE_CP     | SCLK_CNTL__FORCE_HDP  |
  56                         SCLK_CNTL__FORCE_DISP1  | SCLK_CNTL__FORCE_TOP  |
  57                         SCLK_CNTL__FORCE_E2     | SCLK_CNTL__FORCE_SE   |
  58                         SCLK_CNTL__FORCE_IDCT   | SCLK_CNTL__FORCE_VIP  |
  59                         SCLK_CNTL__FORCE_RE     | SCLK_CNTL__FORCE_PB   |
  60                         SCLK_CNTL__FORCE_TAM    | SCLK_CNTL__FORCE_TDM  |
  61                         SCLK_CNTL__FORCE_RB);
  62                 OUTPLL(pllSCLK_CNTL, tmp);
  63                 return;
  64         }
  65         /* RV350 (M10/M11) */
  66         if (rinfo->family == CHIP_FAMILY_RV350) {
  67                 /* for RV350/M10/M11, no delays are required. */
  68                 tmp = INPLL(pllSCLK_CNTL2);
  69                 tmp |= (SCLK_CNTL2__R300_FORCE_TCL |
  70                         SCLK_CNTL2__R300_FORCE_GA  |
  71                         SCLK_CNTL2__R300_FORCE_CBA);
  72                 OUTPLL(pllSCLK_CNTL2, tmp);
  73
  74                 tmp = INPLL(pllSCLK_CNTL);
  75                 tmp |= (SCLK_CNTL__FORCE_DISP2          | SCLK_CNTL__FORCE_CP           |
  76                         SCLK_CNTL__FORCE_HDP            | SCLK_CNTL__FORCE_DISP1        |
  77                         SCLK_CNTL__FORCE_TOP            | SCLK_CNTL__FORCE_E2           |
  78                         SCLK_CNTL__R300_FORCE_VAP       | SCLK_CNTL__FORCE_IDCT         |
  79                         SCLK_CNTL__FORCE_VIP            | SCLK_CNTL__R300_FORCE_SR      |
  80                         SCLK_CNTL__R300_FORCE_PX        | SCLK_CNTL__R300_FORCE_TX      |
  81                         SCLK_CNTL__R300_FORCE_US        | SCLK_CNTL__FORCE_TV_SCLK      |
  82                         SCLK_CNTL__R300_FORCE_SU        | SCLK_CNTL__FORCE_OV0);
  83                 OUTPLL(pllSCLK_CNTL, tmp);
  84
  85                 tmp = INPLL(pllSCLK_MORE_CNTL);
  86                 tmp |= (SCLK_MORE_CNTL__FORCE_DISPREGS  | SCLK_MORE_CNTL__FORCE_MC_GUI  |
  87                         SCLK_MORE_CNTL__FORCE_MC_HOST);
  88                 OUTPLL(pllSCLK_MORE_CNTL, tmp);
  89
  90                 tmp = INPLL(pllMCLK_CNTL);
  91                 tmp |= (MCLK_CNTL__FORCE_MCLKA |
  92                         MCLK_CNTL__FORCE_MCLKB |
  93                         MCLK_CNTL__FORCE_YCLKA |
  94                         MCLK_CNTL__FORCE_YCLKB |
  95                         MCLK_CNTL__FORCE_MC);
  96                 OUTPLL(pllMCLK_CNTL, tmp);
  97
  98                 tmp = INPLL(pllVCLK_ECP_CNTL);
  99                 tmp &= ~(VCLK_ECP_CNTL__PIXCLK_ALWAYS_ONb  |
 100                          VCLK_ECP_CNTL__PIXCLK_DAC_ALWAYS_ONb |
 101                          VCLK_ECP_CNTL__R300_DISP_DAC_PIXCLK_DAC_BLANK_OFF);
 102                 OUTPLL(pllVCLK_ECP_CNTL, tmp);
 103
 104                 tmp = INPLL(pllPIXCLKS_CNTL);
 105                 tmp &= ~(PIXCLKS_CNTL__PIX2CLK_ALWAYS_ONb               |
 106                          PIXCLKS_CNTL__PIX2CLK_DAC_ALWAYS_ONb           |
 107                          PIXCLKS_CNTL__DISP_TVOUT_PIXCLK_TV_ALWAYS_ONb  |
 108                          PIXCLKS_CNTL__R300_DVOCLK_ALWAYS_ONb           |
 109                          PIXCLKS_CNTL__PIXCLK_BLEND_ALWAYS_ONb          |
 110                          PIXCLKS_CNTL__PIXCLK_GV_ALWAYS_ONb             |
 111                          PIXCLKS_CNTL__R300_PIXCLK_DVO_ALWAYS_ONb       |
 112                          PIXCLKS_CNTL__PIXCLK_LVDS_ALWAYS_ONb           |
 113                          PIXCLKS_CNTL__PIXCLK_TMDS_ALWAYS_ONb           |
 114                          PIXCLKS_CNTL__R300_PIXCLK_TRANS_ALWAYS_ONb     |
 115                          PIXCLKS_CNTL__R300_PIXCLK_TVO_ALWAYS_ONb       |
 116                          PIXCLKS_CNTL__R300_P2G2CLK_ALWAYS_ONb          |
 117                          PIXCLKS_CNTL__R300_P2G2CLK_ALWAYS_ONb          |
 118                          PIXCLKS_CNTL__R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF);
 119                 OUTPLL(pllPIXCLKS_CNTL, tmp);
 120
 121                 return;
 122         }
 123
 124         /* Default */
 125
 126         /* Force Core Clocks */
 127         tmp = INPLL(pllSCLK_CNTL);
 128         tmp |= (SCLK_CNTL__FORCE_CP | SCLK_CNTL__FORCE_E2);
 129
 130         /* XFree doesn't do that case, but we had this code from Apple and it
 131          * seem necessary for proper suspend/resume operations
 132          */
 133         if (rinfo->is_mobility) {
 134                 tmp |=  SCLK_CNTL__FORCE_HDP|
 135                         SCLK_CNTL__FORCE_DISP1|
 136                         SCLK_CNTL__FORCE_DISP2|
 137                         SCLK_CNTL__FORCE_TOP|
 138                         SCLK_CNTL__FORCE_SE|
 139                         SCLK_CNTL__FORCE_IDCT|
 140                         SCLK_CNTL__FORCE_VIP|
 141                         SCLK_CNTL__FORCE_PB|
 142                         SCLK_CNTL__FORCE_RE|
 143                         SCLK_CNTL__FORCE_TAM|
 144                         SCLK_CNTL__FORCE_TDM|
 145                         SCLK_CNTL__FORCE_RB|
 146                         SCLK_CNTL__FORCE_TV_SCLK|
 147                         SCLK_CNTL__FORCE_SUBPIC|
 148                         SCLK_CNTL__FORCE_OV0;
 149         }
 150         else if (rinfo->family == CHIP_FAMILY_R300 ||
 151                    rinfo->family == CHIP_FAMILY_R350) {
 152                 tmp |=  SCLK_CNTL__FORCE_HDP   |
 153                         SCLK_CNTL__FORCE_DISP1 |
 154                         SCLK_CNTL__FORCE_DISP2 |
 155                         SCLK_CNTL__FORCE_TOP   |
 156                         SCLK_CNTL__FORCE_IDCT  |
 157                         SCLK_CNTL__FORCE_VIP;
 158         }
 159         OUTPLL(pllSCLK_CNTL, tmp);
 160         radeon_msleep(16);
 161
 162         if (rinfo->family == CHIP_FAMILY_R300 || rinfo->family == CHIP_FAMILY_R350) {
 163                 tmp = INPLL(pllSCLK_CNTL2);
 164                 tmp |=  SCLK_CNTL2__R300_FORCE_TCL |
 165                         SCLK_CNTL2__R300_FORCE_GA  |
 166                         SCLK_CNTL2__R300_FORCE_CBA;
 167                 OUTPLL(pllSCLK_CNTL2, tmp);
 168                 radeon_msleep(16);
 169         }
 170
 171         tmp = INPLL(pllCLK_PIN_CNTL);
 172         tmp &= ~CLK_PIN_CNTL__SCLK_DYN_START_CNTL;
 173         OUTPLL(pllCLK_PIN_CNTL, tmp);
 174         radeon_msleep(15);
 175
 176         if (rinfo->is_IGP) {
 177                 /* Weird  ... X is _un_ forcing clocks here, I think it's
 178                  * doing backward. Imitate it for now...
 179                  */
 180                 tmp = INPLL(pllMCLK_CNTL);
 181                 tmp &= ~(MCLK_CNTL__FORCE_MCLKA |
 182                          MCLK_CNTL__FORCE_YCLKA);
 183                 OUTPLL(pllMCLK_CNTL, tmp);
 184                 radeon_msleep(16);
 185         }
 186         /* Hrm... same shit, X doesn't do that but I have to */
 187         else if (rinfo->is_mobility) {
 188                 tmp = INPLL(pllMCLK_CNTL);
 189                 tmp |= (MCLK_CNTL__FORCE_MCLKA |
 190                         MCLK_CNTL__FORCE_MCLKB |
 191                         MCLK_CNTL__FORCE_YCLKA |
 192                         MCLK_CNTL__FORCE_YCLKB);
 193                 OUTPLL(pllMCLK_CNTL, tmp);
 194                 radeon_msleep(16);
 195
 196                 tmp = INPLL(pllMCLK_MISC);
 197                 tmp &=  ~(MCLK_MISC__MC_MCLK_MAX_DYN_STOP_LAT|
 198                           MCLK_MISC__IO_MCLK_MAX_DYN_STOP_LAT|
 199                           MCLK_MISC__MC_MCLK_DYN_ENABLE|
 200                           MCLK_MISC__IO_MCLK_DYN_ENABLE);
 201                 OUTPLL(pllMCLK_MISC, tmp);
 202                 radeon_msleep(15);
 203         }
 204
 205         if (rinfo->is_mobility) {
 206                 tmp = INPLL(pllSCLK_MORE_CNTL);
 207                 tmp |=  SCLK_MORE_CNTL__FORCE_DISPREGS|
 208                         SCLK_MORE_CNTL__FORCE_MC_GUI|
 209                         SCLK_MORE_CNTL__FORCE_MC_HOST;
 210                 OUTPLL(pllSCLK_MORE_CNTL, tmp);
 211                 radeon_msleep(16);
 212         }
 213
 214         tmp = INPLL(pllPIXCLKS_CNTL);
 215         tmp &= ~(PIXCLKS_CNTL__PIXCLK_GV_ALWAYS_ONb |
 216                  PIXCLKS_CNTL__PIXCLK_BLEND_ALWAYS_ONb|
 217                  PIXCLKS_CNTL__PIXCLK_DIG_TMDS_ALWAYS_ONb |
 218                  PIXCLKS_CNTL__PIXCLK_LVDS_ALWAYS_ONb|
 219                  PIXCLKS_CNTL__PIXCLK_TMDS_ALWAYS_ONb|
 220                  PIXCLKS_CNTL__PIX2CLK_ALWAYS_ONb|
 221                  PIXCLKS_CNTL__PIX2CLK_DAC_ALWAYS_ONb);
 222         OUTPLL(pllPIXCLKS_CNTL, tmp);
 223         radeon_msleep(16);
 224
 225         tmp = INPLL( pllVCLK_ECP_CNTL);
 226         tmp &= ~(VCLK_ECP_CNTL__PIXCLK_ALWAYS_ONb |
 227                  VCLK_ECP_CNTL__PIXCLK_DAC_ALWAYS_ONb);
 228         OUTPLL( pllVCLK_ECP_CNTL, tmp);
 229         radeon_msleep(16);
 230 }
 231
 232 static void radeon_pm_enable_dynamic_mode(struct radeonfb_info *rinfo)
 233 {
 234         u32 tmp;
 235
 236         /* R100 */
 237         if (!rinfo->has_CRTC2) {
 238                 tmp = INPLL(pllSCLK_CNTL);
 239
 240                 if ((INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK) > CFG_ATI_REV_A13)
 241                     tmp &= ~(SCLK_CNTL__FORCE_CP        | SCLK_CNTL__FORCE_RB);
 242                 tmp &= ~(SCLK_CNTL__FORCE_HDP           | SCLK_CNTL__FORCE_DISP1 |
 243                          SCLK_CNTL__FORCE_TOP           | SCLK_CNTL__FORCE_SE   |
 244                          SCLK_CNTL__FORCE_IDCT          | SCLK_CNTL__FORCE_RE   |
 245                          SCLK_CNTL__FORCE_PB            | SCLK_CNTL__FORCE_TAM  |
 246                          SCLK_CNTL__FORCE_TDM);
 247                 OUTPLL(pllSCLK_CNTL, tmp);
 248                 return;
 249         }
 250
 251         /* M10/M11 */
 252         if (rinfo->family == CHIP_FAMILY_RV350) {
 253                 tmp = INPLL(pllSCLK_CNTL2);
 254                 tmp &= ~(SCLK_CNTL2__R300_FORCE_TCL |
 255                          SCLK_CNTL2__R300_FORCE_GA  |
 256                          SCLK_CNTL2__R300_FORCE_CBA);
 257                 tmp |=  (SCLK_CNTL2__R300_TCL_MAX_DYN_STOP_LAT |
 258                          SCLK_CNTL2__R300_GA_MAX_DYN_STOP_LAT  |
 259                          SCLK_CNTL2__R300_CBA_MAX_DYN_STOP_LAT);
 260                 OUTPLL(pllSCLK_CNTL2, tmp);
 261
 262                 tmp = INPLL(pllSCLK_CNTL);
 263                 tmp &= ~(SCLK_CNTL__FORCE_DISP2 | SCLK_CNTL__FORCE_CP      |
 264                          SCLK_CNTL__FORCE_HDP   | SCLK_CNTL__FORCE_DISP1   |
 265                          SCLK_CNTL__FORCE_TOP   | SCLK_CNTL__FORCE_E2      |
 266                          SCLK_CNTL__R300_FORCE_VAP | SCLK_CNTL__FORCE_IDCT |
 267                          SCLK_CNTL__FORCE_VIP   | SCLK_CNTL__R300_FORCE_SR |
 268                          SCLK_CNTL__R300_FORCE_PX | SCLK_CNTL__R300_FORCE_TX |
 269                          SCLK_CNTL__R300_FORCE_US | SCLK_CNTL__FORCE_TV_SCLK |
 270                          SCLK_CNTL__R300_FORCE_SU | SCLK_CNTL__FORCE_OV0);
 271                 tmp |= SCLK_CNTL__DYN_STOP_LAT_MASK;
 272                 OUTPLL(pllSCLK_CNTL, tmp);
 273
 274                 tmp = INPLL(pllSCLK_MORE_CNTL);
 275                 tmp &= ~SCLK_MORE_CNTL__FORCEON;
 276                 tmp |=  SCLK_MORE_CNTL__DISPREGS_MAX_DYN_STOP_LAT |
 277                         SCLK_MORE_CNTL__MC_GUI_MAX_DYN_STOP_LAT |
 278                         SCLK_MORE_CNTL__MC_HOST_MAX_DYN_STOP_LAT;
 279                 OUTPLL(pllSCLK_MORE_CNTL, tmp);
 280
 281                 tmp = INPLL(pllVCLK_ECP_CNTL);
 282                 tmp |= (VCLK_ECP_CNTL__PIXCLK_ALWAYS_ONb |
 283                         VCLK_ECP_CNTL__PIXCLK_DAC_ALWAYS_ONb);
 284                 OUTPLL(pllVCLK_ECP_CNTL, tmp);
 285
 286                 tmp = INPLL(pllPIXCLKS_CNTL);
 287                 tmp |= (PIXCLKS_CNTL__PIX2CLK_ALWAYS_ONb         |
 288                         PIXCLKS_CNTL__PIX2CLK_DAC_ALWAYS_ONb     |
 289                         PIXCLKS_CNTL__DISP_TVOUT_PIXCLK_TV_ALWAYS_ONb |
 290                         PIXCLKS_CNTL__R300_DVOCLK_ALWAYS_ONb            |
 291                         PIXCLKS_CNTL__PIXCLK_BLEND_ALWAYS_ONb    |
 292                         PIXCLKS_CNTL__PIXCLK_GV_ALWAYS_ONb       |
 293                         PIXCLKS_CNTL__R300_PIXCLK_DVO_ALWAYS_ONb        |
 294                         PIXCLKS_CNTL__PIXCLK_LVDS_ALWAYS_ONb     |
 295                         PIXCLKS_CNTL__PIXCLK_TMDS_ALWAYS_ONb     |
 296                         PIXCLKS_CNTL__R300_PIXCLK_TRANS_ALWAYS_ONb      |
 297                         PIXCLKS_CNTL__R300_PIXCLK_TVO_ALWAYS_ONb        |
 298                         PIXCLKS_CNTL__R300_P2G2CLK_ALWAYS_ONb           |
 299                         PIXCLKS_CNTL__R300_P2G2CLK_ALWAYS_ONb);
 300                 OUTPLL(pllPIXCLKS_CNTL, tmp);
 301
 302                 tmp = INPLL(pllMCLK_MISC);
 303                 tmp |= (MCLK_MISC__MC_MCLK_DYN_ENABLE |
 304                         MCLK_MISC__IO_MCLK_DYN_ENABLE);
 305                 OUTPLL(pllMCLK_MISC, tmp);
 306
 307                 tmp = INPLL(pllMCLK_CNTL);
 308                 tmp |= (MCLK_CNTL__FORCE_MCLKA | MCLK_CNTL__FORCE_MCLKB);
 309                 tmp &= ~(MCLK_CNTL__FORCE_YCLKA  |
 310                          MCLK_CNTL__FORCE_YCLKB  |
 311                          MCLK_CNTL__FORCE_MC);
 312
 313                 /* Some releases of vbios have set DISABLE_MC_MCLKA
 314                  * and DISABLE_MC_MCLKB bits in the vbios table.  Setting these
 315                  * bits will cause H/W hang when reading video memory with dynamic
 316                  * clocking enabled.
 317                  */
 318                 if ((tmp & MCLK_CNTL__R300_DISABLE_MC_MCLKA) &&
 319                     (tmp & MCLK_CNTL__R300_DISABLE_MC_MCLKB)) {
 320                         /* If both bits are set, then check the active channels */
 321                         tmp = INPLL(pllMCLK_CNTL);
 322                         if (rinfo->vram_width == 64) {
 323                             if (INREG(MEM_CNTL) & R300_MEM_USE_CD_CH_ONLY)
 324                                 tmp &= ~MCLK_CNTL__R300_DISABLE_MC_MCLKB;
 325                             else
 326                                 tmp &= ~MCLK_CNTL__R300_DISABLE_MC_MCLKA;
 327                         } else {
 328                             tmp &= ~(MCLK_CNTL__R300_DISABLE_MC_MCLKA |
 329                                      MCLK_CNTL__R300_DISABLE_MC_MCLKB);
 330                         }
 331                 }
 332                 OUTPLL(pllMCLK_CNTL, tmp);
 333                 return;
 334         }
 335
 336         /* R300 */
 337         if (rinfo->family == CHIP_FAMILY_R300 || rinfo->family == CHIP_FAMILY_R350) {
 338                 tmp = INPLL(pllSCLK_CNTL);
 339                 tmp &= ~(SCLK_CNTL__R300_FORCE_VAP);
 340                 tmp |= SCLK_CNTL__FORCE_CP;
 341                 OUTPLL(pllSCLK_CNTL, tmp);
 342                 radeon_msleep(15);
 343
 344                 tmp = INPLL(pllSCLK_CNTL2);
 345                 tmp &= ~(SCLK_CNTL2__R300_FORCE_TCL |
 346                          SCLK_CNTL2__R300_FORCE_GA  |
 347                          SCLK_CNTL2__R300_FORCE_CBA);
 348                 OUTPLL(pllSCLK_CNTL2, tmp);
 349         }
 350
 351         /* Others */
 352
 353         tmp = INPLL( pllCLK_PWRMGT_CNTL);
 354         tmp &= ~(CLK_PWRMGT_CNTL__ACTIVE_HILO_LAT_MASK|
 355                  CLK_PWRMGT_CNTL__DISP_DYN_STOP_LAT_MASK|
 356                  CLK_PWRMGT_CNTL__DYN_STOP_MODE_MASK);
 357         tmp |= CLK_PWRMGT_CNTL__ENGINE_DYNCLK_MODE_MASK |
 358                (0x01 << CLK_PWRMGT_CNTL__ACTIVE_HILO_LAT__SHIFT);
 359         OUTPLL( pllCLK_PWRMGT_CNTL, tmp);
 360         radeon_msleep(15);
 361
 362         tmp = INPLL(pllCLK_PIN_CNTL);
 363         tmp |= CLK_PIN_CNTL__SCLK_DYN_START_CNTL;
 364         OUTPLL(pllCLK_PIN_CNTL, tmp);
 365         radeon_msleep(15);
 366
 367         /* When DRI is enabled, setting DYN_STOP_LAT to zero can cause some R200
 368          * to lockup randomly, leave them as set by BIOS.
 369          */
 370         tmp = INPLL(pllSCLK_CNTL);
 371         tmp &= ~SCLK_CNTL__FORCEON_MASK;
 372
 373         /*RAGE_6::A11 A12 A12N1 A13, RV250::A11 A12, R300*/
 374         if ((rinfo->family == CHIP_FAMILY_RV250 &&
 375              ((INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK) < CFG_ATI_REV_A13)) ||
 376             ((rinfo->family == CHIP_FAMILY_RV100) &&
 377              ((INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK) <= CFG_ATI_REV_A13))) {
 378                 tmp |= SCLK_CNTL__FORCE_CP;
 379                 tmp |= SCLK_CNTL__FORCE_VIP;
 380         }
 381         OUTPLL(pllSCLK_CNTL, tmp);
 382         radeon_msleep(15);
 383
 384         if ((rinfo->family == CHIP_FAMILY_RV200) ||
 385             (rinfo->family == CHIP_FAMILY_RV250) ||
 386             (rinfo->family == CHIP_FAMILY_RV280)) {
 387                 tmp = INPLL(pllSCLK_MORE_CNTL);
 388                 tmp &= ~SCLK_MORE_CNTL__FORCEON;
 389
 390                 /* RV200::A11 A12 RV250::A11 A12 */
 391                 if (((rinfo->family == CHIP_FAMILY_RV200) ||
 392                      (rinfo->family == CHIP_FAMILY_RV250)) &&
 393                     ((INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK) < CFG_ATI_REV_A13))
 394                         tmp |= SCLK_MORE_CNTL__FORCEON;
 395
 396                 OUTPLL(pllSCLK_MORE_CNTL, tmp);
 397                 radeon_msleep(15);
 398         }
 399
 400
 401         /* RV200::A11 A12, RV250::A11 A12 */
 402         if (((rinfo->family == CHIP_FAMILY_RV200) ||
 403              (rinfo->family == CHIP_FAMILY_RV250)) &&
 404             ((INREG(CONFIG_CNTL) & CFG_ATI_REV_ID_MASK) < CFG_ATI_REV_A13)) {
 405                 tmp = INPLL(pllPLL_PWRMGT_CNTL);
 406                 tmp |= PLL_PWRMGT_CNTL__TCL_BYPASS_DISABLE;
 407                 OUTPLL(pllPLL_PWRMGT_CNTL, tmp);
 408                 radeon_msleep(15);
 409         }
 410
 411         tmp = INPLL(pllPIXCLKS_CNTL);
 412         tmp |=  PIXCLKS_CNTL__PIX2CLK_ALWAYS_ONb |
 413                 PIXCLKS_CNTL__PIX2CLK_DAC_ALWAYS_ONb|
 414                 PIXCLKS_CNTL__PIXCLK_BLEND_ALWAYS_ONb|
 415                 PIXCLKS_CNTL__PIXCLK_GV_ALWAYS_ONb|
 416                 PIXCLKS_CNTL__PIXCLK_DIG_TMDS_ALWAYS_ONb|
 417                 PIXCLKS_CNTL__PIXCLK_LVDS_ALWAYS_ONb|
 418                 PIXCLKS_CNTL__PIXCLK_TMDS_ALWAYS_ONb;
 419         OUTPLL(pllPIXCLKS_CNTL, tmp);
 420         radeon_msleep(15);
 421
 422         tmp = INPLL(pllVCLK_ECP_CNTL);
 423         tmp |=  VCLK_ECP_CNTL__PIXCLK_ALWAYS_ONb |
 424                 VCLK_ECP_CNTL__PIXCLK_DAC_ALWAYS_ONb;
 425         OUTPLL(pllVCLK_ECP_CNTL, tmp);
 426
 427         /* X doesn't do that ... hrm, we do on mobility && Macs */
 428 #ifdef CONFIG_PPC_OF
 429         if (rinfo->is_mobility) {
 430                 tmp  = INPLL(pllMCLK_CNTL);
 431                 tmp &= ~(MCLK_CNTL__FORCE_MCLKA |
 432                          MCLK_CNTL__FORCE_MCLKB |
 433                          MCLK_CNTL__FORCE_YCLKA |
 434                          MCLK_CNTL__FORCE_YCLKB);
 435                 OUTPLL(pllMCLK_CNTL, tmp);
 436                 radeon_msleep(15);
 437
 438                 tmp = INPLL(pllMCLK_MISC);
 439                 tmp |=  MCLK_MISC__MC_MCLK_MAX_DYN_STOP_LAT|
 440                         MCLK_MISC__IO_MCLK_MAX_DYN_STOP_LAT|
 441                         MCLK_MISC__MC_MCLK_DYN_ENABLE|
 442                         MCLK_MISC__IO_MCLK_DYN_ENABLE;
 443                 OUTPLL(pllMCLK_MISC, tmp);
 444                 radeon_msleep(15);
 445         }
 446 #endif /* CONFIG_PPC_OF */
 447 }
 448
 449 #ifdef CONFIG_PM
 450
 451 static void OUTMC( struct radeonfb_info *rinfo, u8 indx, u32 value)
 452 {
 453         OUTREG( MC_IND_INDEX, indx | MC_IND_INDEX__MC_IND_WR_EN);
 454         OUTREG( MC_IND_DATA, value);
 455 }
 456
 457 static u32 INMC(struct radeonfb_info *rinfo, u8 indx)
 458 {
 459         OUTREG( MC_IND_INDEX, indx);
 460         return INREG( MC_IND_DATA);
 461 }
 462
 463 static void radeon_pm_save_regs(struct radeonfb_info *rinfo, int saving_for_d3)
 464 {
 465         rinfo->save_regs[0] = INPLL(PLL_PWRMGT_CNTL);
 466         rinfo->save_regs[1] = INPLL(CLK_PWRMGT_CNTL);
 467         rinfo->save_regs[2] = INPLL(MCLK_CNTL);
 468         rinfo->save_regs[3] = INPLL(SCLK_CNTL);
 469         rinfo->save_regs[4] = INPLL(CLK_PIN_CNTL);
 470         rinfo->save_regs[5] = INPLL(VCLK_ECP_CNTL);
 471         rinfo->save_regs[6] = INPLL(PIXCLKS_CNTL);
 472         rinfo->save_regs[7] = INPLL(MCLK_MISC);
 473         rinfo->save_regs[8] = INPLL(P2PLL_CNTL);
 474
 475         rinfo->save_regs[9] = INREG(DISP_MISC_CNTL);
 476         rinfo->save_regs[10] = INREG(DISP_PWR_MAN);
 477         rinfo->save_regs[11] = INREG(LVDS_GEN_CNTL);
 478         rinfo->save_regs[13] = INREG(TV_DAC_CNTL);
 479         rinfo->save_regs[14] = INREG(BUS_CNTL1);
 480         rinfo->save_regs[15] = INREG(CRTC_OFFSET_CNTL);
 481         rinfo->save_regs[16] = INREG(AGP_CNTL);
 482         rinfo->save_regs[17] = (INREG(CRTC_GEN_CNTL) & 0xfdffffff) | 0x04000000;
 483         rinfo->save_regs[18] = (INREG(CRTC2_GEN_CNTL) & 0xfdffffff) | 0x04000000;
 484         rinfo->save_regs[19] = INREG(GPIOPAD_A);
 485         rinfo->save_regs[20] = INREG(GPIOPAD_EN);
 486         rinfo->save_regs[21] = INREG(GPIOPAD_MASK);
 487         rinfo->save_regs[22] = INREG(ZV_LCDPAD_A);
 488         rinfo->save_regs[23] = INREG(ZV_LCDPAD_EN);
 489         rinfo->save_regs[24] = INREG(ZV_LCDPAD_MASK);
 490         rinfo->save_regs[25] = INREG(GPIO_VGA_DDC);
 491         rinfo->save_regs[26] = INREG(GPIO_DVI_DDC);
 492         rinfo->save_regs[27] = INREG(GPIO_MONID);
 493         rinfo->save_regs[28] = INREG(GPIO_CRT2_DDC);
 494
 495         rinfo->save_regs[29] = INREG(SURFACE_CNTL);
 496         rinfo->save_regs[30] = INREG(MC_FB_LOCATION);
 497         rinfo->save_regs[31] = INREG(DISPLAY_BASE_ADDR);
 498         rinfo->save_regs[32] = INREG(MC_AGP_LOCATION);
 499         rinfo->save_regs[33] = INREG(CRTC2_DISPLAY_BASE_ADDR);
 500
 501         rinfo->save_regs[34] = INPLL(SCLK_MORE_CNTL);
 502         rinfo->save_regs[35] = INREG(MEM_SDRAM_MODE_REG);
 503         rinfo->save_regs[36] = INREG(BUS_CNTL);
 504         rinfo->save_regs[39] = INREG(RBBM_CNTL);
 505         rinfo->save_regs[40] = INREG(DAC_CNTL);
 506         rinfo->save_regs[41] = INREG(HOST_PATH_CNTL);
 507         rinfo->save_regs[37] = INREG(MPP_TB_CONFIG);
 508         rinfo->save_regs[38] = INREG(FCP_CNTL);
 509
 510         if (rinfo->is_mobility) {
 511                 rinfo->save_regs[12] = INREG(LVDS_PLL_CNTL);
 512                 rinfo->save_regs[43] = INPLL(pllSSPLL_CNTL);
 513                 rinfo->save_regs[44] = INPLL(pllSSPLL_REF_DIV);
 514                 rinfo->save_regs[45] = INPLL(pllSSPLL_DIV_0);
 515                 rinfo->save_regs[90] = INPLL(pllSS_INT_CNTL);
 516                 rinfo->save_regs[91] = INPLL(pllSS_TST_CNTL);
 517                 rinfo->save_regs[81] = INREG(LVDS_GEN_CNTL);
 518         }
 519
 520         if (rinfo->family >= CHIP_FAMILY_RV200) {
 521                 rinfo->save_regs[42] = INREG(MEM_REFRESH_CNTL);
 522                 rinfo->save_regs[46] = INREG(MC_CNTL);
 523                 rinfo->save_regs[47] = INREG(MC_INIT_GFX_LAT_TIMER);
 524                 rinfo->save_regs[48] = INREG(MC_INIT_MISC_LAT_TIMER);
 525                 rinfo->save_regs[49] = INREG(MC_TIMING_CNTL);
 526                 rinfo->save_regs[50] = INREG(MC_READ_CNTL_AB);
 527                 rinfo->save_regs[51] = INREG(MC_IOPAD_CNTL);
 528                 rinfo->save_regs[52] = INREG(MC_CHIP_IO_OE_CNTL_AB);
 529                 rinfo->save_regs[53] = INREG(MC_DEBUG);
 530         }
 531         rinfo->save_regs[54] = INREG(PAMAC0_DLY_CNTL);
 532         rinfo->save_regs[55] = INREG(PAMAC1_DLY_CNTL);
 533         rinfo->save_regs[56] = INREG(PAD_CTLR_MISC);
 534         rinfo->save_regs[57] = INREG(FW_CNTL);
 535
 536         if (rinfo->family >= CHIP_FAMILY_R300) {
 537                 rinfo->save_regs[58] = INMC(rinfo, ixR300_MC_MC_INIT_WR_LAT_TIMER);
 538                 rinfo->save_regs[59] = INMC(rinfo, ixR300_MC_IMP_CNTL);
 539                 rinfo->save_regs[60] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_C0);
 540                 rinfo->save_regs[61] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_C1);
 541                 rinfo->save_regs[62] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_D0);
 542                 rinfo->save_regs[63] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_D1);
 543                 rinfo->save_regs[64] = INMC(rinfo, ixR300_MC_BIST_CNTL_3);
 544                 rinfo->save_regs[65] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_A0);
 545                 rinfo->save_regs[66] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_A1);
 546                 rinfo->save_regs[67] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_B0);
 547                 rinfo->save_regs[68] = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_B1);
 548                 rinfo->save_regs[69] = INMC(rinfo, ixR300_MC_DEBUG_CNTL);
 549                 rinfo->save_regs[70] = INMC(rinfo, ixR300_MC_DLL_CNTL);
 550                 rinfo->save_regs[71] = INMC(rinfo, ixR300_MC_IMP_CNTL_0);
 551                 rinfo->save_regs[72] = INMC(rinfo, ixR300_MC_ELPIDA_CNTL);
 552                 rinfo->save_regs[96] = INMC(rinfo, ixR300_MC_READ_CNTL_CD);
 553         } else {
 554                 rinfo->save_regs[59] = INMC(rinfo, ixMC_IMP_CNTL);
 555                 rinfo->save_regs[65] = INMC(rinfo, ixMC_CHP_IO_CNTL_A0);
 556                 rinfo->save_regs[66] = INMC(rinfo, ixMC_CHP_IO_CNTL_A1);
 557                 rinfo->save_regs[67] = INMC(rinfo, ixMC_CHP_IO_CNTL_B0);
 558                 rinfo->save_regs[68] = INMC(rinfo, ixMC_CHP_IO_CNTL_B1);
 559                 rinfo->save_regs[71] = INMC(rinfo, ixMC_IMP_CNTL_0);
 560         }
 561
 562         rinfo->save_regs[73] = INPLL(pllMPLL_CNTL);
 563         rinfo->save_regs[74] = INPLL(pllSPLL_CNTL);
 564         rinfo->save_regs[75] = INPLL(pllMPLL_AUX_CNTL);
 565         rinfo->save_regs[76] = INPLL(pllSPLL_AUX_CNTL);
 566         rinfo->save_regs[77] = INPLL(pllM_SPLL_REF_FB_DIV);
 567         rinfo->save_regs[78] = INPLL(pllAGP_PLL_CNTL);
 568         rinfo->save_regs[79] = INREG(PAMAC2_DLY_CNTL);
 569
 570         rinfo->save_regs[80] = INREG(OV0_BASE_ADDR);
 571         rinfo->save_regs[82] = INREG(FP_GEN_CNTL);
 572         rinfo->save_regs[83] = INREG(FP2_GEN_CNTL);
 573         rinfo->save_regs[84] = INREG(TMDS_CNTL);
 574         rinfo->save_regs[85] = INREG(TMDS_TRANSMITTER_CNTL);
 575         rinfo->save_regs[86] = INREG(DISP_OUTPUT_CNTL);
 576         rinfo->save_regs[87] = INREG(DISP_HW_DEBUG);
 577         rinfo->save_regs[88] = INREG(TV_MASTER_CNTL);
 578         rinfo->save_regs[89] = INPLL(pllP2PLL_REF_DIV);
 579         rinfo->save_regs[92] = INPLL(pllPPLL_DIV_0);
 580         rinfo->save_regs[93] = INPLL(pllPPLL_CNTL);
 581         rinfo->save_regs[94] = INREG(GRPH_BUFFER_CNTL);
 582         rinfo->save_regs[95] = INREG(GRPH2_BUFFER_CNTL);
 583         rinfo->save_regs[96] = INREG(HDP_DEBUG);
 584         rinfo->save_regs[97] = INPLL(pllMDLL_CKO);
 585         rinfo->save_regs[98] = INPLL(pllMDLL_RDCKA);
 586         rinfo->save_regs[99] = INPLL(pllMDLL_RDCKB);
 587 }
 588
 589 static void radeon_pm_restore_regs(struct radeonfb_info *rinfo)
 590 {
 591         OUTPLL(P2PLL_CNTL, rinfo->save_regs[8] & 0xFFFFFFFE); /* First */
 592
 593         OUTPLL(PLL_PWRMGT_CNTL, rinfo->save_regs[0]);
 594         OUTPLL(CLK_PWRMGT_CNTL, rinfo->save_regs[1]);
 595         OUTPLL(MCLK_CNTL, rinfo->save_regs[2]);
 596         OUTPLL(SCLK_CNTL, rinfo->save_regs[3]);
 597         OUTPLL(CLK_PIN_CNTL, rinfo->save_regs[4]);
 598         OUTPLL(VCLK_ECP_CNTL, rinfo->save_regs[5]);
 599         OUTPLL(PIXCLKS_CNTL, rinfo->save_regs[6]);
 600         OUTPLL(MCLK_MISC, rinfo->save_regs[7]);
 601         if (rinfo->family == CHIP_FAMILY_RV350)
 602                 OUTPLL(SCLK_MORE_CNTL, rinfo->save_regs[34]);
 603
 604         OUTREG(SURFACE_CNTL, rinfo->save_regs[29]);
 605         OUTREG(MC_FB_LOCATION, rinfo->save_regs[30]);
 606         OUTREG(DISPLAY_BASE_ADDR, rinfo->save_regs[31]);
 607         OUTREG(MC_AGP_LOCATION, rinfo->save_regs[32]);
 608         OUTREG(CRTC2_DISPLAY_BASE_ADDR, rinfo->save_regs[33]);
 609         OUTREG(CONFIG_MEMSIZE, rinfo->video_ram);
 610
 611         OUTREG(DISP_MISC_CNTL, rinfo->save_regs[9]);
 612         OUTREG(DISP_PWR_MAN, rinfo->save_regs[10]);
 613         OUTREG(LVDS_GEN_CNTL, rinfo->save_regs[11]);
 614         OUTREG(LVDS_PLL_CNTL,rinfo->save_regs[12]);
 615         OUTREG(TV_DAC_CNTL, rinfo->save_regs[13]);
 616         OUTREG(BUS_CNTL1, rinfo->save_regs[14]);
 617         OUTREG(CRTC_OFFSET_CNTL, rinfo->save_regs[15]);
 618         OUTREG(AGP_CNTL, rinfo->save_regs[16]);
 619         OUTREG(CRTC_GEN_CNTL, rinfo->save_regs[17]);
 620         OUTREG(CRTC2_GEN_CNTL, rinfo->save_regs[18]);
 621         OUTPLL(P2PLL_CNTL, rinfo->save_regs[8]);
 622
 623         OUTREG(GPIOPAD_A, rinfo->save_regs[19]);
 624         OUTREG(GPIOPAD_EN, rinfo->save_regs[20]);
 625         OUTREG(GPIOPAD_MASK, rinfo->save_regs[21]);
 626         OUTREG(ZV_LCDPAD_A, rinfo->save_regs[22]);
 627         OUTREG(ZV_LCDPAD_EN, rinfo->save_regs[23]);
 628         OUTREG(ZV_LCDPAD_MASK, rinfo->save_regs[24]);
 629         OUTREG(GPIO_VGA_DDC, rinfo->save_regs[25]);
 630         OUTREG(GPIO_DVI_DDC, rinfo->save_regs[26]);
 631         OUTREG(GPIO_MONID, rinfo->save_regs[27]);
 632         OUTREG(GPIO_CRT2_DDC, rinfo->save_regs[28]);
 633 }
 634
 635 static void radeon_pm_disable_iopad(struct radeonfb_info *rinfo)
 636 {
 637         OUTREG(GPIOPAD_MASK, 0x0001ffff);
 638         OUTREG(GPIOPAD_EN, 0x00000400);
 639         OUTREG(GPIOPAD_A, 0x00000000);
 640         OUTREG(ZV_LCDPAD_MASK, 0x00000000);
 641         OUTREG(ZV_LCDPAD_EN, 0x00000000);
 642         OUTREG(ZV_LCDPAD_A, 0x00000000);
 643         OUTREG(GPIO_VGA_DDC, 0x00030000);
 644         OUTREG(GPIO_DVI_DDC, 0x00000000);
 645         OUTREG(GPIO_MONID, 0x00030000);
 646         OUTREG(GPIO_CRT2_DDC, 0x00000000);
 647 }
 648
 649 static void radeon_pm_program_v2clk(struct radeonfb_info *rinfo)
 650 {
 651         /* Set v2clk to 65MHz */
 652         if (rinfo->family <= CHIP_FAMILY_RV280) {
 653                 OUTPLL(pllPIXCLKS_CNTL,
 654                          __INPLL(rinfo, pllPIXCLKS_CNTL)
 655                          & ~PIXCLKS_CNTL__PIX2CLK_SRC_SEL_MASK);
 656
 657                 OUTPLL(pllP2PLL_REF_DIV, 0x0000000c);
 658                 OUTPLL(pllP2PLL_CNTL, 0x0000bf00);
 659         } else {
 660                 OUTPLL(pllP2PLL_REF_DIV, 0x0000000c);
 661                 INPLL(pllP2PLL_REF_DIV);
 662                 OUTPLL(pllP2PLL_CNTL, 0x0000a700);
 663         }
 664
 665         OUTPLL(pllP2PLL_DIV_0, 0x00020074 | P2PLL_DIV_0__P2PLL_ATOMIC_UPDATE_W);
 666
 667         OUTPLL(pllP2PLL_CNTL, INPLL(pllP2PLL_CNTL) & ~P2PLL_CNTL__P2PLL_SLEEP);
 668         mdelay(1);
 669
 670         OUTPLL(pllP2PLL_CNTL, INPLL(pllP2PLL_CNTL) & ~P2PLL_CNTL__P2PLL_RESET);
 671         mdelay( 1);
 672
 673         OUTPLL(pllPIXCLKS_CNTL,
 674                 (INPLL(pllPIXCLKS_CNTL) & ~PIXCLKS_CNTL__PIX2CLK_SRC_SEL_MASK)
 675                 | (0x03 << PIXCLKS_CNTL__PIX2CLK_SRC_SEL__SHIFT));
 676         mdelay( 1);
 677 }
 678
 679 static void radeon_pm_low_current(struct radeonfb_info *rinfo)
 680 {
 681         u32 reg;
 682
 683         reg  = INREG(BUS_CNTL1);
 684         if (rinfo->family <= CHIP_FAMILY_RV280) {
 685                 reg &= ~BUS_CNTL1_MOBILE_PLATFORM_SEL_MASK;
 686                 reg |= BUS_CNTL1_AGPCLK_VALID | (1<<BUS_CNTL1_MOBILE_PLATFORM_SEL_SHIFT);
 687         } else {
 688                 reg |= 0x4080;
 689         }
 690         OUTREG(BUS_CNTL1, reg);
 691
 692         reg  = INPLL(PLL_PWRMGT_CNTL);
 693         reg |= PLL_PWRMGT_CNTL_SPLL_TURNOFF | PLL_PWRMGT_CNTL_PPLL_TURNOFF |
 694                 PLL_PWRMGT_CNTL_P2PLL_TURNOFF | PLL_PWRMGT_CNTL_TVPLL_TURNOFF;
 695         reg &= ~PLL_PWRMGT_CNTL_SU_MCLK_USE_BCLK;
 696         reg &= ~PLL_PWRMGT_CNTL_MOBILE_SU;
 697         OUTPLL(PLL_PWRMGT_CNTL, reg);
 698
 699         reg  = INREG(TV_DAC_CNTL);
 700         reg &= ~(TV_DAC_CNTL_BGADJ_MASK |TV_DAC_CNTL_DACADJ_MASK);
 701         reg |=TV_DAC_CNTL_BGSLEEP | TV_DAC_CNTL_RDACPD | TV_DAC_CNTL_GDACPD |
 702                 TV_DAC_CNTL_BDACPD |
 703                 (8<<TV_DAC_CNTL_BGADJ__SHIFT) | (8<<TV_DAC_CNTL_DACADJ__SHIFT);
 704         OUTREG(TV_DAC_CNTL, reg);
 705
 706         reg  = INREG(TMDS_TRANSMITTER_CNTL);
 707         reg &= ~(TMDS_PLL_EN | TMDS_PLLRST);
 708         OUTREG(TMDS_TRANSMITTER_CNTL, reg);
 709
 710         reg = INREG(DAC_CNTL);
 711         reg &= ~DAC_CMP_EN;
 712         OUTREG(DAC_CNTL, reg);
 713
 714         reg = INREG(DAC_CNTL2);
 715         reg &= ~DAC2_CMP_EN;
 716         OUTREG(DAC_CNTL2, reg);
 717
 718         reg  = INREG(TV_DAC_CNTL);
 719         reg &= ~TV_DAC_CNTL_DETECT;
 720         OUTREG(TV_DAC_CNTL, reg);
 721 }
 722
 723 static void radeon_pm_setup_for_suspend(struct radeonfb_info *rinfo)
 724 {
 725
 726         u32 sclk_cntl, mclk_cntl, sclk_more_cntl;
 727
 728         u32 pll_pwrmgt_cntl;
 729         u32 clk_pwrmgt_cntl;
 730         u32 clk_pin_cntl;
 731         u32 vclk_ecp_cntl;
 732         u32 pixclks_cntl;
 733         u32 disp_mis_cntl;
 734         u32 disp_pwr_man;
 735         u32 tmp;
 736
 737         /* Force Core Clocks */
 738         sclk_cntl = INPLL( pllSCLK_CNTL);
 739         sclk_cntl |=    SCLK_CNTL__IDCT_MAX_DYN_STOP_LAT|
 740                         SCLK_CNTL__VIP_MAX_DYN_STOP_LAT|
 741                         SCLK_CNTL__RE_MAX_DYN_STOP_LAT|
 742                         SCLK_CNTL__PB_MAX_DYN_STOP_LAT|
 743                         SCLK_CNTL__TAM_MAX_DYN_STOP_LAT|
 744                         SCLK_CNTL__TDM_MAX_DYN_STOP_LAT|
 745                         SCLK_CNTL__RB_MAX_DYN_STOP_LAT|
 746
 747                         SCLK_CNTL__FORCE_DISP2|
 748                         SCLK_CNTL__FORCE_CP|
 749                         SCLK_CNTL__FORCE_HDP|
 750                         SCLK_CNTL__FORCE_DISP1|
 751                         SCLK_CNTL__FORCE_TOP|
 752                         SCLK_CNTL__FORCE_E2|
 753                         SCLK_CNTL__FORCE_SE|
 754                         SCLK_CNTL__FORCE_IDCT|
 755                         SCLK_CNTL__FORCE_VIP|
 756
 757                         SCLK_CNTL__FORCE_PB|
 758                         SCLK_CNTL__FORCE_TAM|
 759                         SCLK_CNTL__FORCE_TDM|
 760                         SCLK_CNTL__FORCE_RB|
 761                         SCLK_CNTL__FORCE_TV_SCLK|
 762                         SCLK_CNTL__FORCE_SUBPIC|
 763                         SCLK_CNTL__FORCE_OV0;
 764         if (rinfo->family <= CHIP_FAMILY_RV280)
 765                 sclk_cntl |= SCLK_CNTL__FORCE_RE;
 766         else
 767                 sclk_cntl |= SCLK_CNTL__SE_MAX_DYN_STOP_LAT |
 768                         SCLK_CNTL__E2_MAX_DYN_STOP_LAT |
 769                         SCLK_CNTL__TV_MAX_DYN_STOP_LAT |
 770                         SCLK_CNTL__HDP_MAX_DYN_STOP_LAT |
 771                         SCLK_CNTL__CP_MAX_DYN_STOP_LAT;
 772
 773         OUTPLL( pllSCLK_CNTL, sclk_cntl);
 774
 775         sclk_more_cntl = INPLL(pllSCLK_MORE_CNTL);
 776         sclk_more_cntl |=       SCLK_MORE_CNTL__FORCE_DISPREGS |
 777                                 SCLK_MORE_CNTL__FORCE_MC_GUI |
 778                                 SCLK_MORE_CNTL__FORCE_MC_HOST;
 779
 780         OUTPLL(pllSCLK_MORE_CNTL, sclk_more_cntl);
 781
 782
 783         mclk_cntl = INPLL( pllMCLK_CNTL);
 784         mclk_cntl &= ~( MCLK_CNTL__FORCE_MCLKA |
 785                         MCLK_CNTL__FORCE_MCLKB |
 786                         MCLK_CNTL__FORCE_YCLKA |
 787                         MCLK_CNTL__FORCE_YCLKB |
 788                         MCLK_CNTL__FORCE_MC
 789                       );
 790         OUTPLL( pllMCLK_CNTL, mclk_cntl);
 791
 792         /* Force Display clocks */
 793         vclk_ecp_cntl = INPLL( pllVCLK_ECP_CNTL);
 794         vclk_ecp_cntl &= ~(VCLK_ECP_CNTL__PIXCLK_ALWAYS_ONb
 795                            | VCLK_ECP_CNTL__PIXCLK_DAC_ALWAYS_ONb);
 796         vclk_ecp_cntl |= VCLK_ECP_CNTL__ECP_FORCE_ON;
 797         OUTPLL( pllVCLK_ECP_CNTL, vclk_ecp_cntl);
 798
 799
 800         pixclks_cntl = INPLL( pllPIXCLKS_CNTL);
 801         pixclks_cntl &= ~(      PIXCLKS_CNTL__PIXCLK_GV_ALWAYS_ONb |
 802                                 PIXCLKS_CNTL__PIXCLK_BLEND_ALWAYS_ONb|
 803                                 PIXCLKS_CNTL__PIXCLK_DIG_TMDS_ALWAYS_ONb |
 804                                 PIXCLKS_CNTL__PIXCLK_LVDS_ALWAYS_ONb|
 805                                 PIXCLKS_CNTL__PIXCLK_TMDS_ALWAYS_ONb|
 806                                 PIXCLKS_CNTL__PIX2CLK_ALWAYS_ONb|
 807                                 PIXCLKS_CNTL__PIX2CLK_DAC_ALWAYS_ONb);
 808
 809         OUTPLL( pllPIXCLKS_CNTL, pixclks_cntl);
 810
 811         /* Switch off LVDS interface */
 812         OUTREG(LVDS_GEN_CNTL, INREG(LVDS_GEN_CNTL) &
 813                ~(LVDS_BLON | LVDS_EN | LVDS_ON | LVDS_DIGON));
 814
 815         /* Enable System power management */
 816         pll_pwrmgt_cntl = INPLL( pllPLL_PWRMGT_CNTL);
 817
 818         pll_pwrmgt_cntl |=      PLL_PWRMGT_CNTL__SPLL_TURNOFF |
 819                                 PLL_PWRMGT_CNTL__MPLL_TURNOFF|
 820                                 PLL_PWRMGT_CNTL__PPLL_TURNOFF|
 821                                 PLL_PWRMGT_CNTL__P2PLL_TURNOFF|
 822                                 PLL_PWRMGT_CNTL__TVPLL_TURNOFF;
 823
 824         OUTPLL( pllPLL_PWRMGT_CNTL, pll_pwrmgt_cntl);
 825
 826         clk_pwrmgt_cntl  = INPLL( pllCLK_PWRMGT_CNTL);
 827
 828         clk_pwrmgt_cntl &= ~(   CLK_PWRMGT_CNTL__MPLL_PWRMGT_OFF|
 829                                 CLK_PWRMGT_CNTL__SPLL_PWRMGT_OFF|
 830                                 CLK_PWRMGT_CNTL__PPLL_PWRMGT_OFF|
 831                                 CLK_PWRMGT_CNTL__P2PLL_PWRMGT_OFF|
 832                                 CLK_PWRMGT_CNTL__MCLK_TURNOFF|
 833                                 CLK_PWRMGT_CNTL__SCLK_TURNOFF|
 834                                 CLK_PWRMGT_CNTL__PCLK_TURNOFF|
 835                                 CLK_PWRMGT_CNTL__P2CLK_TURNOFF|
 836                                 CLK_PWRMGT_CNTL__TVPLL_PWRMGT_OFF|
 837                                 CLK_PWRMGT_CNTL__GLOBAL_PMAN_EN|
 838                                 CLK_PWRMGT_CNTL__ENGINE_DYNCLK_MODE|
 839                                 CLK_PWRMGT_CNTL__ACTIVE_HILO_LAT_MASK|
 840                                 CLK_PWRMGT_CNTL__CG_NO1_DEBUG_MASK
 841                         );
 842
 843         clk_pwrmgt_cntl |= CLK_PWRMGT_CNTL__GLOBAL_PMAN_EN
 844                 | CLK_PWRMGT_CNTL__DISP_PM;
 845
 846         OUTPLL( pllCLK_PWRMGT_CNTL, clk_pwrmgt_cntl);
 847
 848         clk_pin_cntl = INPLL( pllCLK_PIN_CNTL);
 849
 850         clk_pin_cntl &= ~CLK_PIN_CNTL__ACCESS_REGS_IN_SUSPEND;
 851
 852         /* because both INPLL and OUTPLL take the same lock, that's why. */
 853         tmp = INPLL( pllMCLK_MISC) | MCLK_MISC__EN_MCLK_TRISTATE_IN_SUSPEND;
 854         OUTPLL( pllMCLK_MISC, tmp);
 855
 856         /* AGP PLL control */
 857         if (rinfo->family <= CHIP_FAMILY_RV280) {
 858                 OUTREG(BUS_CNTL1, INREG(BUS_CNTL1) |  BUS_CNTL1__AGPCLK_VALID);
 859
 860                 OUTREG(BUS_CNTL1,
 861                        (INREG(BUS_CNTL1) & ~BUS_CNTL1__MOBILE_PLATFORM_SEL_MASK)
 862                        | (2<<BUS_CNTL1__MOBILE_PLATFORM_SEL__SHIFT));   // 440BX
 863         } else {
 864                 OUTREG(BUS_CNTL1, INREG(BUS_CNTL1));
 865                 OUTREG(BUS_CNTL1, (INREG(BUS_CNTL1) & ~0x4000) | 0x8000);
 866         }
 867
 868         OUTREG(CRTC_OFFSET_CNTL, (INREG(CRTC_OFFSET_CNTL)
 869                                   & ~CRTC_OFFSET_CNTL__CRTC_STEREO_SYNC_OUT_EN));
 870
 871         clk_pin_cntl &= ~CLK_PIN_CNTL__CG_CLK_TO_OUTPIN;
 872         clk_pin_cntl |= CLK_PIN_CNTL__XTALIN_ALWAYS_ONb;
 873         OUTPLL( pllCLK_PIN_CNTL, clk_pin_cntl);
 874
 875         /* Solano2M */
 876         OUTREG(AGP_CNTL,
 877                 (INREG(AGP_CNTL) & ~(AGP_CNTL__MAX_IDLE_CLK_MASK))
 878                 | (0x20<<AGP_CNTL__MAX_IDLE_CLK__SHIFT));
 879
 880         /* ACPI mode */
 881         /* because both INPLL and OUTPLL take the same lock, that's why. */
 882         tmp = INPLL( pllPLL_PWRMGT_CNTL) & ~PLL_PWRMGT_CNTL__PM_MODE_SEL;
 883         OUTPLL( pllPLL_PWRMGT_CNTL, tmp);
 884
 885
 886         disp_mis_cntl = INREG(DISP_MISC_CNTL);
 887
 888         disp_mis_cntl &= ~(     DISP_MISC_CNTL__SOFT_RESET_GRPH_PP |
 889                                 DISP_MISC_CNTL__SOFT_RESET_SUBPIC_PP |
 890                                 DISP_MISC_CNTL__SOFT_RESET_OV0_PP |
 891                                 DISP_MISC_CNTL__SOFT_RESET_GRPH_SCLK|
 892                                 DISP_MISC_CNTL__SOFT_RESET_SUBPIC_SCLK|
 893                                 DISP_MISC_CNTL__SOFT_RESET_OV0_SCLK|
 894                                 DISP_MISC_CNTL__SOFT_RESET_GRPH2_PP|
 895                                 DISP_MISC_CNTL__SOFT_RESET_GRPH2_SCLK|
 896                                 DISP_MISC_CNTL__SOFT_RESET_LVDS|
 897                                 DISP_MISC_CNTL__SOFT_RESET_TMDS|
 898                                 DISP_MISC_CNTL__SOFT_RESET_DIG_TMDS|
 899                                 DISP_MISC_CNTL__SOFT_RESET_TV);
 900
 901         OUTREG(DISP_MISC_CNTL, disp_mis_cntl);
 902
 903         disp_pwr_man = INREG(DISP_PWR_MAN);
 904
 905         disp_pwr_man &= ~(      DISP_PWR_MAN__DISP_PWR_MAN_D3_CRTC_EN   |
 906                                 DISP_PWR_MAN__DISP2_PWR_MAN_D3_CRTC2_EN |
 907                                 DISP_PWR_MAN__DISP_PWR_MAN_DPMS_MASK|
 908                                 DISP_PWR_MAN__DISP_D3_RST|
 909                                 DISP_PWR_MAN__DISP_D3_REG_RST
 910                                 );
 911
 912         disp_pwr_man |= DISP_PWR_MAN__DISP_D3_GRPH_RST|
 913                                         DISP_PWR_MAN__DISP_D3_SUBPIC_RST|
 914                                         DISP_PWR_MAN__DISP_D3_OV0_RST|
 915                                         DISP_PWR_MAN__DISP_D1D2_GRPH_RST|
 916                                         DISP_PWR_MAN__DISP_D1D2_SUBPIC_RST|
 917                                         DISP_PWR_MAN__DISP_D1D2_OV0_RST|
 918                                         DISP_PWR_MAN__DIG_TMDS_ENABLE_RST|
 919                                         DISP_PWR_MAN__TV_ENABLE_RST|
 920 //                                      DISP_PWR_MAN__AUTO_PWRUP_EN|
 921                                         0;
 922
 923         OUTREG(DISP_PWR_MAN, disp_pwr_man);
 924
 925         clk_pwrmgt_cntl = INPLL( pllCLK_PWRMGT_CNTL);
 926         pll_pwrmgt_cntl = INPLL( pllPLL_PWRMGT_CNTL) ;
 927         clk_pin_cntl    = INPLL( pllCLK_PIN_CNTL);
 928         disp_pwr_man    = INREG(DISP_PWR_MAN);
 929
 930
 931         /* D2 */
 932         clk_pwrmgt_cntl |= CLK_PWRMGT_CNTL__DISP_PM;
 933         pll_pwrmgt_cntl |= PLL_PWRMGT_CNTL__MOBILE_SU | PLL_PWRMGT_CNTL__SU_SCLK_USE_BCLK;
 934         clk_pin_cntl    |= CLK_PIN_CNTL__XTALIN_ALWAYS_ONb;
 935         disp_pwr_man    &= ~(DISP_PWR_MAN__DISP_PWR_MAN_D3_CRTC_EN_MASK
 936                              | DISP_PWR_MAN__DISP2_PWR_MAN_D3_CRTC2_EN_MASK);
 937
 938         OUTPLL( pllCLK_PWRMGT_CNTL, clk_pwrmgt_cntl);
 939         OUTPLL( pllPLL_PWRMGT_CNTL, pll_pwrmgt_cntl);
 940         OUTPLL( pllCLK_PIN_CNTL, clk_pin_cntl);
 941         OUTREG(DISP_PWR_MAN, disp_pwr_man);
 942
 943         /* disable display request & disable display */
 944         OUTREG( CRTC_GEN_CNTL, (INREG( CRTC_GEN_CNTL) & ~CRTC_GEN_CNTL__CRTC_EN)
 945                 | CRTC_GEN_CNTL__CRTC_DISP_REQ_EN_B);
 946         OUTREG( CRTC2_GEN_CNTL, (INREG( CRTC2_GEN_CNTL) & ~CRTC2_GEN_CNTL__CRTC2_EN)
 947                 | CRTC2_GEN_CNTL__CRTC2_DISP_REQ_EN_B);
 948
 949         mdelay(17);
 950
 951 }
 952
 953 static void radeon_pm_yclk_mclk_sync(struct radeonfb_info *rinfo)
 954 {
 955         u32 mc_chp_io_cntl_a1, mc_chp_io_cntl_b1;
 956
 957         mc_chp_io_cntl_a1 = INMC( rinfo, ixMC_CHP_IO_CNTL_A1)
 958                 & ~MC_CHP_IO_CNTL_A1__MEM_SYNC_ENA_MASK;
 959         mc_chp_io_cntl_b1 = INMC( rinfo, ixMC_CHP_IO_CNTL_B1)
 960                 & ~MC_CHP_IO_CNTL_B1__MEM_SYNC_ENB_MASK;
 961
 962         OUTMC( rinfo, ixMC_CHP_IO_CNTL_A1, mc_chp_io_cntl_a1
 963                | (1<<MC_CHP_IO_CNTL_A1__MEM_SYNC_ENA__SHIFT));
 964         OUTMC( rinfo, ixMC_CHP_IO_CNTL_B1, mc_chp_io_cntl_b1
 965                | (1<<MC_CHP_IO_CNTL_B1__MEM_SYNC_ENB__SHIFT));
 966
 967         OUTMC( rinfo, ixMC_CHP_IO_CNTL_A1, mc_chp_io_cntl_a1);
 968         OUTMC( rinfo, ixMC_CHP_IO_CNTL_B1, mc_chp_io_cntl_b1);
 969
 970         mdelay( 1);
 971 }
 972
 973 static void radeon_pm_yclk_mclk_sync_m10(struct radeonfb_info *rinfo)
 974 {
 975         u32 mc_chp_io_cntl_a1, mc_chp_io_cntl_b1;
 976
 977         mc_chp_io_cntl_a1 = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_A1)
 978                 & ~MC_CHP_IO_CNTL_A1__MEM_SYNC_ENA_MASK;
 979         mc_chp_io_cntl_b1 = INMC(rinfo, ixR300_MC_CHP_IO_CNTL_B1)
 980                 & ~MC_CHP_IO_CNTL_B1__MEM_SYNC_ENB_MASK;
 981
 982         OUTMC( rinfo, ixR300_MC_CHP_IO_CNTL_A1,
 983                mc_chp_io_cntl_a1 | (1<<MC_CHP_IO_CNTL_A1__MEM_SYNC_ENA__SHIFT));
 984         OUTMC( rinfo, ixR300_MC_CHP_IO_CNTL_B1,
 985                mc_chp_io_cntl_b1 | (1<<MC_CHP_IO_CNTL_B1__MEM_SYNC_ENB__SHIFT));
 986
 987         OUTMC( rinfo, ixR300_MC_CHP_IO_CNTL_A1, mc_chp_io_cntl_a1);
 988         OUTMC( rinfo, ixR300_MC_CHP_IO_CNTL_B1, mc_chp_io_cntl_b1);
 989
 990         mdelay( 1);
 991 }
 992
 993 static void radeon_pm_program_mode_reg(struct radeonfb_info *rinfo, u16 value,
 994                                        u8 delay_required)
 995 {
 996         u32 mem_sdram_mode;
 997
 998         mem_sdram_mode  = INREG( MEM_SDRAM_MODE_REG);
 999
1000         mem_sdram_mode &= ~MEM_SDRAM_MODE_REG__MEM_MODE_REG_MASK;
1001         mem_sdram_mode |= (value<<MEM_SDRAM_MODE_REG__MEM_MODE_REG__SHIFT)
1002                 | MEM_SDRAM_MODE_REG__MEM_CFG_TYPE;
1003         OUTREG( MEM_SDRAM_MODE_REG, mem_sdram_mode);
1004         if (delay_required >= 2)
1005                 mdelay(1);
1006
1007         mem_sdram_mode |=  MEM_SDRAM_MODE_REG__MEM_SDRAM_RESET;
1008         OUTREG( MEM_SDRAM_MODE_REG, mem_sdram_mode);
1009         if (delay_required >= 2)
1010                 mdelay(1);
1011
1012         mem_sdram_mode &= ~MEM_SDRAM_MODE_REG__MEM_SDRAM_RESET;
1013         OUTREG( MEM_SDRAM_MODE_REG, mem_sdram_mode);
1014         if (delay_required >= 2)
1015                 mdelay(1);
1016
1017         if (delay_required) {
1018                 do {
1019                         if (delay_required >= 2)
1020                                 mdelay(1);
1021                 } while ((INREG(MC_STATUS)
1022                           & (MC_STATUS__MEM_PWRUP_COMPL_A |
1023                              MC_STATUS__MEM_PWRUP_COMPL_B)) == 0);
1024         }
1025 }
1026
1027 static void radeon_pm_m10_program_mode_wait(struct radeonfb_info *rinfo)
1028 {
1029         int cnt;
1030
1031         for (cnt = 0; cnt < 100; ++cnt) {
1032                 mdelay(1);
1033                 if (INREG(MC_STATUS) & (MC_STATUS__MEM_PWRUP_COMPL_A
1034                                         | MC_STATUS__MEM_PWRUP_COMPL_B))
1035                         break;
1036         }
1037 }
1038
1039
1040 static void radeon_pm_enable_dll(struct radeonfb_info *rinfo)
1041 {
1042 #define DLL_RESET_DELAY         5
1043 #define DLL_SLEEP_DELAY         1
1044
1045         u32 cko = INPLL(pllMDLL_CKO)   | MDLL_CKO__MCKOA_SLEEP
1046                 | MDLL_CKO__MCKOA_RESET;
1047         u32 cka = INPLL(pllMDLL_RDCKA) | MDLL_RDCKA__MRDCKA0_SLEEP
1048                 | MDLL_RDCKA__MRDCKA1_SLEEP | MDLL_RDCKA__MRDCKA0_RESET
1049                 | MDLL_RDCKA__MRDCKA1_RESET;
1050         u32 ckb = INPLL(pllMDLL_RDCKB) | MDLL_RDCKB__MRDCKB0_SLEEP
1051                 | MDLL_RDCKB__MRDCKB1_SLEEP | MDLL_RDCKB__MRDCKB0_RESET
1052                 | MDLL_RDCKB__MRDCKB1_RESET;
1053
1054         /* Setting up the DLL range for write */
1055         OUTPLL(pllMDLL_CKO,     cko);
1056         OUTPLL(pllMDLL_RDCKA,   cka);
1057         OUTPLL(pllMDLL_RDCKB,   ckb);
1058
1059         mdelay(DLL_RESET_DELAY*2);
1060
1061         cko &= ~(MDLL_CKO__MCKOA_SLEEP | MDLL_CKO__MCKOB_SLEEP);
1062         OUTPLL(pllMDLL_CKO, cko);
1063         mdelay(DLL_SLEEP_DELAY);
1064         cko &= ~(MDLL_CKO__MCKOA_RESET | MDLL_CKO__MCKOB_RESET);
1065         OUTPLL(pllMDLL_CKO, cko);
1066         mdelay(DLL_RESET_DELAY);
1067
1068         cka &= ~(MDLL_RDCKA__MRDCKA0_SLEEP | MDLL_RDCKA__MRDCKA1_SLEEP);
1069         OUTPLL(pllMDLL_RDCKA, cka);
1070         mdelay(DLL_SLEEP_DELAY);
1071         cka &= ~(MDLL_RDCKA__MRDCKA0_RESET | MDLL_RDCKA__MRDCKA1_RESET);
1072         OUTPLL(pllMDLL_RDCKA, cka);
1073         mdelay(DLL_RESET_DELAY);
1074
1075         ckb &= ~(MDLL_RDCKB__MRDCKB0_SLEEP | MDLL_RDCKB__MRDCKB1_SLEEP);
1076         OUTPLL(pllMDLL_RDCKB, ckb);
1077         mdelay(DLL_SLEEP_DELAY);
1078         ckb &= ~(MDLL_RDCKB__MRDCKB0_RESET | MDLL_RDCKB__MRDCKB1_RESET);
1079         OUTPLL(pllMDLL_RDCKB, ckb);
1080         mdelay(DLL_RESET_DELAY);
1081
1082
1083 #undef DLL_RESET_DELAY
1084 #undef DLL_SLEEP_DELAY
1085 }
1086
1087 static void radeon_pm_enable_dll_m10(struct radeonfb_info *rinfo)
1088 {
1089         u32 dll_value;
1090         u32 dll_sleep_mask = 0;
1091         u32 dll_reset_mask = 0;
1092         u32 mc;
1093
1094 #define DLL_RESET_DELAY         5
1095 #define DLL_SLEEP_DELAY         1
1096
1097         OUTMC(rinfo, ixR300_MC_DLL_CNTL, rinfo->save_regs[70]);
1098         mc = INREG(MC_CNTL);
1099         /* Check which channels are enabled */
1100         switch (mc & 0x3) {
1101         case 1:
1102                 if (mc & 0x4)
1103                         break;
1104         case 2:
1105                 dll_sleep_mask |= MDLL_R300_RDCK__MRDCKB_SLEEP;
1106                 dll_reset_mask |= MDLL_R300_RDCK__MRDCKB_RESET;
1107         case 0:
1108                 dll_sleep_mask |= MDLL_R300_RDCK__MRDCKA_SLEEP;
1109                 dll_reset_mask |= MDLL_R300_RDCK__MRDCKA_RESET;
1110         }
1111         switch (mc & 0x3) {
1112         case 1:
1113                 if (!(mc & 0x4))
1114                         break;
1115         case 2:
1116                 dll_sleep_mask |= MDLL_R300_RDCK__MRDCKD_SLEEP;
1117                 dll_reset_mask |= MDLL_R300_RDCK__MRDCKD_RESET;
1118                 dll_sleep_mask |= MDLL_R300_RDCK__MRDCKC_SLEEP;
1119                 dll_reset_mask |= MDLL_R300_RDCK__MRDCKC_RESET;
1120         }
1121
1122         dll_value = INPLL(pllMDLL_RDCKA);
1123
1124         /* Power Up */
1125         dll_value &= ~(dll_sleep_mask);
1126         OUTPLL(pllMDLL_RDCKA, dll_value);
1127         mdelay( DLL_SLEEP_DELAY);
1128
1129         dll_value &= ~(dll_reset_mask);
1130         OUTPLL(pllMDLL_RDCKA, dll_value);
1131         mdelay( DLL_RESET_DELAY);
1132
1133 #undef DLL_RESET_DELAY
1134 #undef DLL_SLEEP_DELAY
1135 }
1136
1137
1138 static void radeon_pm_full_reset_sdram(struct radeonfb_info *rinfo)
1139 {
1140         u32 crtcGenCntl, crtcGenCntl2, memRefreshCntl, crtc_more_cntl,
1141                 fp_gen_cntl, fp2_gen_cntl;
1142
1143         crtcGenCntl  = INREG( CRTC_GEN_CNTL);
1144         crtcGenCntl2 = INREG( CRTC2_GEN_CNTL);
1145
1146         crtc_more_cntl  = INREG( CRTC_MORE_CNTL);
1147         fp_gen_cntl     = INREG( FP_GEN_CNTL);
1148         fp2_gen_cntl    = INREG( FP2_GEN_CNTL);
1149
1150
1151         OUTREG( CRTC_MORE_CNTL, 0);
1152         OUTREG( FP_GEN_CNTL, 0);
1153         OUTREG( FP2_GEN_CNTL,0);
1154
1155         OUTREG( CRTC_GEN_CNTL,  (crtcGenCntl | CRTC_GEN_CNTL__CRTC_DISP_REQ_EN_B) );
1156         OUTREG( CRTC2_GEN_CNTL, (crtcGenCntl2 | CRTC2_GEN_CNTL__CRTC2_DISP_REQ_EN_B) );
1157
1158         /* This is the code for the Aluminium PowerBooks M10 / iBooks M11 */
1159         if (rinfo->family == CHIP_FAMILY_RV350) {
1160                 u32 sdram_mode_reg = rinfo->save_regs[35];
1161                 static u32 default_mrtable[] =
1162                         { 0x21320032,
1163                           0x21321000, 0xa1321000, 0x21321000, 0xffffffff,
1164                           0x21320032, 0xa1320032, 0x21320032, 0xffffffff,
1165                           0x21321002, 0xa1321002, 0x21321002, 0xffffffff,
1166                           0x21320132, 0xa1320132, 0x21320132, 0xffffffff,
1167                           0x21320032, 0xa1320032, 0x21320032, 0xffffffff,
1168                           0x31320032 };
1169
1170                 u32 *mrtable = default_mrtable;
1171                 int i, mrtable_size = ARRAY_SIZE(default_mrtable);
1172
1173                 mdelay(30);
1174
1175                 /* Disable refresh */
1176                 memRefreshCntl  = INREG( MEM_REFRESH_CNTL)
1177                         & ~MEM_REFRESH_CNTL__MEM_REFRESH_DIS;
1178                 OUTREG( MEM_REFRESH_CNTL, memRefreshCntl
1179                         | MEM_REFRESH_CNTL__MEM_REFRESH_DIS);
1180
1181                 /* Configure and enable M & SPLLs */
1182                 radeon_pm_enable_dll_m10(rinfo);
1183                 radeon_pm_yclk_mclk_sync_m10(rinfo);
1184
1185 #ifdef CONFIG_PPC_OF
1186                 if (rinfo->of_node != NULL) {
1187                         int size;
1188
1189                         mrtable = (u32 *)get_property(rinfo->of_node, "ATY,MRT", &size);
1190                         if (mrtable)
1191                                 mrtable_size = size >> 2;
1192                         else
1193                                 mrtable = default_mrtable;
1194                 }
1195 #endif /* CONFIG_PPC_OF */
1196
1197                 /* Program the SDRAM */
1198                 sdram_mode_reg = mrtable[0];
1199                 OUTREG(MEM_SDRAM_MODE_REG, sdram_mode_reg);
1200                 for (i = 0; i < mrtable_size; i++) {
1201                         if (mrtable[i] == 0xffffffffu)
1202                                 radeon_pm_m10_program_mode_wait(rinfo);
1203                         else {
1204                                 sdram_mode_reg &= ~(MEM_SDRAM_MODE_REG__MEM_MODE_REG_MASK
1205                                                     | MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE
1206                                                     | MEM_SDRAM_MODE_REG__MEM_SDRAM_RESET);
1207                                 sdram_mode_reg |= mrtable[i];
1208
1209                                 OUTREG(MEM_SDRAM_MODE_REG, sdram_mode_reg);
1210                                 mdelay(1);
1211                         }
1212                 }
1213
1214                 /* Restore memory refresh */
1215                 OUTREG(MEM_REFRESH_CNTL, memRefreshCntl);
1216                 mdelay(30);
1217
1218         }
1219         /* Here come the desktop RV200 "QW" card */
1220         else if (!rinfo->is_mobility && rinfo->family == CHIP_FAMILY_RV200) {
1221                 /* Disable refresh */
1222                 memRefreshCntl  = INREG( MEM_REFRESH_CNTL)
1223                         & ~MEM_REFRESH_CNTL__MEM_REFRESH_DIS;
1224                 OUTREG(MEM_REFRESH_CNTL, memRefreshCntl
1225                        | MEM_REFRESH_CNTL__MEM_REFRESH_DIS);
1226                 mdelay(30);
1227
1228                 /* Reset memory */
1229                 OUTREG(MEM_SDRAM_MODE_REG,
1230                        INREG( MEM_SDRAM_MODE_REG) & ~MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1231
1232                 radeon_pm_program_mode_reg(rinfo, 0x2002, 2);
1233                 radeon_pm_program_mode_reg(rinfo, 0x0132, 2);
1234                 radeon_pm_program_mode_reg(rinfo, 0x0032, 2);
1235
1236                 OUTREG(MEM_SDRAM_MODE_REG,
1237                        INREG(MEM_SDRAM_MODE_REG) | MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1238
1239                 OUTREG( MEM_REFRESH_CNTL,       memRefreshCntl);
1240
1241         }
1242         /* The M6 */
1243         else if (rinfo->is_mobility && rinfo->family == CHIP_FAMILY_RV100) {
1244                 /* Disable refresh */
1245                 memRefreshCntl = INREG(EXT_MEM_CNTL) & ~(1 << 20);
1246                 OUTREG( EXT_MEM_CNTL, memRefreshCntl | (1 << 20));
1247
1248                 /* Reset memory */
1249                 OUTREG( MEM_SDRAM_MODE_REG,
1250                         INREG( MEM_SDRAM_MODE_REG)
1251                         & ~MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1252
1253                 /* DLL */
1254                 radeon_pm_enable_dll(rinfo);
1255
1256                 /* MLCK / YCLK sync */
1257                 radeon_pm_yclk_mclk_sync(rinfo);
1258
1259                 /* Program Mode Register */
1260                 radeon_pm_program_mode_reg(rinfo, 0x2000, 1);
1261                 radeon_pm_program_mode_reg(rinfo, 0x2001, 1);
1262                 radeon_pm_program_mode_reg(rinfo, 0x2002, 1);
1263                 radeon_pm_program_mode_reg(rinfo, 0x0132, 1);
1264                 radeon_pm_program_mode_reg(rinfo, 0x0032, 1);
1265
1266                 /* Complete & re-enable refresh */
1267                 OUTREG( MEM_SDRAM_MODE_REG,
1268                         INREG( MEM_SDRAM_MODE_REG) | MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1269
1270                 OUTREG(EXT_MEM_CNTL, memRefreshCntl);
1271         }
1272         /* And finally, the M7..M9 models, including M9+ (RV280) */
1273         else if (rinfo->is_mobility) {
1274
1275                 /* Disable refresh */
1276                 memRefreshCntl  = INREG( MEM_REFRESH_CNTL)
1277                         & ~MEM_REFRESH_CNTL__MEM_REFRESH_DIS;
1278                 OUTREG( MEM_REFRESH_CNTL, memRefreshCntl
1279                         | MEM_REFRESH_CNTL__MEM_REFRESH_DIS);
1280
1281                 /* Reset memory */
1282                 OUTREG( MEM_SDRAM_MODE_REG,
1283                         INREG( MEM_SDRAM_MODE_REG)
1284                         & ~MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1285
1286                 /* DLL */
1287                 radeon_pm_enable_dll(rinfo);
1288
1289                 /* MLCK / YCLK sync */
1290                 radeon_pm_yclk_mclk_sync(rinfo);
1291
1292                 /* M6, M7 and M9 so far ... */
1293                 if (rinfo->family <= CHIP_FAMILY_RV250) {
1294                         radeon_pm_program_mode_reg(rinfo, 0x2000, 1);
1295                         radeon_pm_program_mode_reg(rinfo, 0x2001, 1);
1296                         radeon_pm_program_mode_reg(rinfo, 0x2002, 1);
1297                         radeon_pm_program_mode_reg(rinfo, 0x0132, 1);
1298                         radeon_pm_program_mode_reg(rinfo, 0x0032, 1);
1299                 }
1300                 /* M9+ (iBook G4) */
1301                 else if (rinfo->family == CHIP_FAMILY_RV280) {
1302                         radeon_pm_program_mode_reg(rinfo, 0x2000, 1);
1303                         radeon_pm_program_mode_reg(rinfo, 0x0132, 1);
1304                         radeon_pm_program_mode_reg(rinfo, 0x0032, 1);
1305                 }
1306
1307                 /* Complete & re-enable refresh */
1308                 OUTREG( MEM_SDRAM_MODE_REG,
1309                         INREG( MEM_SDRAM_MODE_REG) | MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1310
1311                 OUTREG( MEM_REFRESH_CNTL,       memRefreshCntl);
1312         }
1313
1314         OUTREG( CRTC_GEN_CNTL,          crtcGenCntl);
1315         OUTREG( CRTC2_GEN_CNTL,         crtcGenCntl2);
1316         OUTREG( FP_GEN_CNTL,            fp_gen_cntl);
1317         OUTREG( FP2_GEN_CNTL,           fp2_gen_cntl);
1318
1319         OUTREG( CRTC_MORE_CNTL,         crtc_more_cntl);
1320
1321         mdelay( 15);
1322 }
1323
1324 static void radeon_pm_reset_pad_ctlr_strength(struct radeonfb_info *rinfo)
1325 {
1326         u32 tmp, tmp2;
1327         int i,j;
1328
1329         /* Reset the PAD_CTLR_STRENGTH & wait for it to be stable */
1330         INREG(PAD_CTLR_STRENGTH);
1331         OUTREG(PAD_CTLR_STRENGTH, INREG(PAD_CTLR_STRENGTH) & ~PAD_MANUAL_OVERRIDE);
1332         tmp = INREG(PAD_CTLR_STRENGTH);
1333         for (i = j = 0; i < 65; ++i) {
1334                 mdelay(1);
1335                 tmp2 = INREG(PAD_CTLR_STRENGTH);
1336                 if (tmp != tmp2) {
1337                         tmp = tmp2;
1338                         i = 0;
1339                         j++;
1340                         if (j > 10) {
1341                                 printk(KERN_WARNING "radeon: PAD_CTLR_STRENGTH doesn't "
1342                                        "stabilize !\n");
1343                                 break;
1344                         }
1345                 }
1346         }
1347 }
1348
1349 static void radeon_pm_all_ppls_off(struct radeonfb_info *rinfo)
1350 {
1351         u32 tmp;
1352
1353         tmp = INPLL(pllPPLL_CNTL);
1354         OUTPLL(pllPPLL_CNTL, tmp | 0x3);
1355         tmp = INPLL(pllP2PLL_CNTL);
1356         OUTPLL(pllP2PLL_CNTL, tmp | 0x3);
1357         tmp = INPLL(pllSPLL_CNTL);
1358         OUTPLL(pllSPLL_CNTL, tmp | 0x3);
1359         tmp = INPLL(pllMPLL_CNTL);
1360         OUTPLL(pllMPLL_CNTL, tmp | 0x3);
1361 }
1362
1363 static void radeon_pm_start_mclk_sclk(struct radeonfb_info *rinfo)
1364 {
1365         u32 tmp;
1366
1367         /* Switch SPLL to PCI source */
1368         tmp = INPLL(pllSCLK_CNTL);
1369         OUTPLL(pllSCLK_CNTL, tmp & ~SCLK_CNTL__SCLK_SRC_SEL_MASK);
1370
1371         /* Reconfigure SPLL charge pump, VCO gain, duty cycle */
1372         tmp = INPLL(pllSPLL_CNTL);
1373         OUTREG8(CLOCK_CNTL_INDEX, pllSPLL_CNTL + PLL_WR_EN);
1374         radeon_pll_errata_after_index(rinfo);
1375         OUTREG8(CLOCK_CNTL_DATA + 1, (tmp >> 8) & 0xff);
1376         radeon_pll_errata_after_data(rinfo);
1377
1378         /* Set SPLL feedback divider */
1379         tmp = INPLL(pllM_SPLL_REF_FB_DIV);
1380         tmp = (tmp & 0xff00fffful) | (rinfo->save_regs[77] & 0x00ff0000ul);
1381         OUTPLL(pllM_SPLL_REF_FB_DIV, tmp);
1382
1383         /* Power up SPLL */
1384         tmp = INPLL(pllSPLL_CNTL);
1385         OUTPLL(pllSPLL_CNTL, tmp & ~1);
1386         (void)INPLL(pllSPLL_CNTL);
1387
1388         mdelay(10);
1389
1390         /* Release SPLL reset */
1391         tmp = INPLL(pllSPLL_CNTL);
1392         OUTPLL(pllSPLL_CNTL, tmp & ~0x2);
1393         (void)INPLL(pllSPLL_CNTL);
1394
1395         mdelay(10);
1396
1397         /* Select SCLK source  */
1398         tmp = INPLL(pllSCLK_CNTL);
1399         tmp &= ~SCLK_CNTL__SCLK_SRC_SEL_MASK;
1400         tmp |= rinfo->save_regs[3] & SCLK_CNTL__SCLK_SRC_SEL_MASK;
1401         OUTPLL(pllSCLK_CNTL, tmp);
1402         (void)INPLL(pllSCLK_CNTL);
1403
1404         mdelay(10);
1405
1406         /* Reconfigure MPLL charge pump, VCO gain, duty cycle */
1407         tmp = INPLL(pllMPLL_CNTL);
1408         OUTREG8(CLOCK_CNTL_INDEX, pllMPLL_CNTL + PLL_WR_EN);
1409         radeon_pll_errata_after_index(rinfo);
1410         OUTREG8(CLOCK_CNTL_DATA + 1, (tmp >> 8) & 0xff);
1411         radeon_pll_errata_after_data(rinfo);
1412
1413         /* Set MPLL feedback divider */
1414         tmp = INPLL(pllM_SPLL_REF_FB_DIV);
1415         tmp = (tmp & 0xffff00fful) | (rinfo->save_regs[77] & 0x0000ff00ul);
1416
1417         OUTPLL(pllM_SPLL_REF_FB_DIV, tmp);
1418         /* Power up MPLL */
1419         tmp = INPLL(pllMPLL_CNTL);
1420         OUTPLL(pllMPLL_CNTL, tmp & ~0x2);
1421         (void)INPLL(pllMPLL_CNTL);
1422
1423         mdelay(10);
1424
1425         /* Un-reset MPLL */
1426         tmp = INPLL(pllMPLL_CNTL);
1427         OUTPLL(pllMPLL_CNTL, tmp & ~0x1);
1428         (void)INPLL(pllMPLL_CNTL);
1429
1430         mdelay(10);
1431
1432         /* Select source for MCLK */
1433         tmp = INPLL(pllMCLK_CNTL);
1434         tmp |= rinfo->save_regs[2] & 0xffff;
1435         OUTPLL(pllMCLK_CNTL, tmp);
1436         (void)INPLL(pllMCLK_CNTL);
1437
1438         mdelay(10);
1439 }
1440
1441 static void radeon_pm_m10_disable_spread_spectrum(struct radeonfb_info *rinfo)
1442 {
1443         u32 r2ec;
1444
1445         /* GACK ! I though we didn't have a DDA on Radeon's anymore
1446          * here we rewrite with the same value, ... I suppose we clear
1447          * some bits that are already clear ? Or maybe this 0x2ec
1448          * register is something new ?
1449          */
1450         mdelay(20);
1451         r2ec = INREG(VGA_DDA_ON_OFF);
1452         OUTREG(VGA_DDA_ON_OFF, r2ec);
1453         mdelay(1);
1454
1455         /* Spread spectrum PLLL off */
1456         OUTPLL(pllSSPLL_CNTL, 0xbf03);
1457
1458         /* Spread spectrum disabled */
1459         OUTPLL(pllSS_INT_CNTL, rinfo->save_regs[90] & ~3);
1460
1461         /* The trace shows read & rewrite of LVDS_PLL_CNTL here with same
1462          * value, not sure what for...
1463          */
1464
1465         r2ec |= 0x3f0;
1466         OUTREG(VGA_DDA_ON_OFF, r2ec);
1467         mdelay(1);
1468 }
1469
1470 static void radeon_pm_m10_enable_lvds_spread_spectrum(struct radeonfb_info *rinfo)
1471 {
1472         u32 r2ec, tmp;
1473
1474         /* GACK (bis) ! I though we didn't have a DDA on Radeon's anymore
1475          * here we rewrite with the same value, ... I suppose we clear/set
1476          * some bits that are already clear/set ?
1477          */
1478         r2ec = INREG(VGA_DDA_ON_OFF);
1479         OUTREG(VGA_DDA_ON_OFF, r2ec);
1480         mdelay(1);
1481
1482         /* Enable spread spectrum */
1483         OUTPLL(pllSSPLL_CNTL, rinfo->save_regs[43] | 3);
1484         mdelay(3);
1485
1486         OUTPLL(pllSSPLL_REF_DIV, rinfo->save_regs[44]);
1487         OUTPLL(pllSSPLL_DIV_0, rinfo->save_regs[45]);
1488         tmp = INPLL(pllSSPLL_CNTL);
1489         OUTPLL(pllSSPLL_CNTL, tmp & ~0x2);
1490         mdelay(6);
1491         tmp = INPLL(pllSSPLL_CNTL);
1492         OUTPLL(pllSSPLL_CNTL, tmp & ~0x1);
1493         mdelay(5);
1494
1495         OUTPLL(pllSS_INT_CNTL, rinfo->save_regs[90]);
1496
1497         r2ec |= 8;
1498         OUTREG(VGA_DDA_ON_OFF, r2ec);
1499         mdelay(20);
1500
1501         /* Enable LVDS interface */
1502         tmp = INREG(LVDS_GEN_CNTL);
1503         OUTREG(LVDS_GEN_CNTL, tmp | LVDS_EN);
1504
1505         /* Enable LVDS_PLL */
1506         tmp = INREG(LVDS_PLL_CNTL);
1507         tmp &= ~0x30000;
1508         tmp |= 0x10000;
1509         OUTREG(LVDS_PLL_CNTL, tmp);
1510
1511         OUTPLL(pllSCLK_MORE_CNTL, rinfo->save_regs[34]);
1512         OUTPLL(pllSS_TST_CNTL, rinfo->save_regs[91]);
1513
1514         /* The trace reads that one here, waiting for something to settle down ? */
1515         INREG(RBBM_STATUS);
1516
1517         /* Ugh ? SS_TST_DEC is supposed to be a read register in the
1518          * R300 register spec at least...
1519          */
1520         tmp = INPLL(pllSS_TST_CNTL);
1521         tmp |= 0x00400000;
1522         OUTPLL(pllSS_TST_CNTL, tmp);
1523 }
1524
1525 static void radeon_pm_restore_pixel_pll(struct radeonfb_info *rinfo)
1526 {
1527         u32 tmp;
1528
1529         OUTREG8(CLOCK_CNTL_INDEX, pllHTOTAL_CNTL + PLL_WR_EN);
1530         radeon_pll_errata_after_index(rinfo);
1531         OUTREG8(CLOCK_CNTL_DATA, 0);
1532         radeon_pll_errata_after_data(rinfo);
1533
1534         tmp = INPLL(pllVCLK_ECP_CNTL);
1535         OUTPLL(pllVCLK_ECP_CNTL, tmp | 0x80);
1536         mdelay(5);
1537
1538         tmp = INPLL(pllPPLL_REF_DIV);
1539         tmp = (tmp & ~PPLL_REF_DIV_MASK) | rinfo->pll.ref_div;
1540         OUTPLL(pllPPLL_REF_DIV, tmp);
1541         INPLL(pllPPLL_REF_DIV);
1542
1543         /* Reconfigure SPLL charge pump, VCO gain, duty cycle,
1544          * probably useless since we already did it ...
1545          */
1546         tmp = INPLL(pllPPLL_CNTL);
1547         OUTREG8(CLOCK_CNTL_INDEX, pllSPLL_CNTL + PLL_WR_EN);
1548         radeon_pll_errata_after_index(rinfo);
1549         OUTREG8(CLOCK_CNTL_DATA + 1, (tmp >> 8) & 0xff);
1550         radeon_pll_errata_after_data(rinfo);
1551
1552         /* Restore our "reference" PPLL divider set by firmware
1553          * according to proper spread spectrum calculations
1554          */
1555         OUTPLL(pllPPLL_DIV_0, rinfo->save_regs[92]);
1556
1557         tmp = INPLL(pllPPLL_CNTL);
1558         OUTPLL(pllPPLL_CNTL, tmp & ~0x2);
1559         mdelay(5);
1560
1561         tmp = INPLL(pllPPLL_CNTL);
1562         OUTPLL(pllPPLL_CNTL, tmp & ~0x1);
1563         mdelay(5);
1564
1565         tmp = INPLL(pllVCLK_ECP_CNTL);
1566         OUTPLL(pllVCLK_ECP_CNTL, tmp | 3);
1567         mdelay(5);
1568
1569         tmp = INPLL(pllVCLK_ECP_CNTL);
1570         OUTPLL(pllVCLK_ECP_CNTL, tmp | 3);
1571         mdelay(5);
1572
1573         /* Switch pixel clock to firmware default div 0 */
1574         OUTREG8(CLOCK_CNTL_INDEX+1, 0);
1575         radeon_pll_errata_after_index(rinfo);
1576         radeon_pll_errata_after_data(rinfo);
1577 }
1578
1579 static void radeon_pm_m10_reconfigure_mc(struct radeonfb_info *rinfo)
1580 {
1581         OUTREG(MC_CNTL, rinfo->save_regs[46]);
1582         OUTREG(MC_INIT_GFX_LAT_TIMER, rinfo->save_regs[47]);
1583         OUTREG(MC_INIT_MISC_LAT_TIMER, rinfo->save_regs[48]);
1584         OUTREG(MEM_SDRAM_MODE_REG,
1585                rinfo->save_regs[35] & ~MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1586         OUTREG(MC_TIMING_CNTL, rinfo->save_regs[49]);
1587         OUTREG(MEM_REFRESH_CNTL, rinfo->save_regs[42]);
1588         OUTREG(MC_READ_CNTL_AB, rinfo->save_regs[50]);
1589         OUTREG(MC_CHIP_IO_OE_CNTL_AB, rinfo->save_regs[52]);
1590         OUTREG(MC_IOPAD_CNTL, rinfo->save_regs[51]);
1591         OUTREG(MC_DEBUG, rinfo->save_regs[53]);
1592
1593         OUTMC(rinfo, ixR300_MC_MC_INIT_WR_LAT_TIMER, rinfo->save_regs[58]);
1594         OUTMC(rinfo, ixR300_MC_IMP_CNTL, rinfo->save_regs[59]);
1595         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_C0, rinfo->save_regs[60]);
1596         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_C1, rinfo->save_regs[61]);
1597         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_D0, rinfo->save_regs[62]);
1598         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_D1, rinfo->save_regs[63]);
1599         OUTMC(rinfo, ixR300_MC_BIST_CNTL_3, rinfo->save_regs[64]);
1600         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_A0, rinfo->save_regs[65]);
1601         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_A1, rinfo->save_regs[66]);
1602         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_B0, rinfo->save_regs[67]);
1603         OUTMC(rinfo, ixR300_MC_CHP_IO_CNTL_B1, rinfo->save_regs[68]);
1604         OUTMC(rinfo, ixR300_MC_DEBUG_CNTL, rinfo->save_regs[69]);
1605         OUTMC(rinfo, ixR300_MC_DLL_CNTL, rinfo->save_regs[70]);
1606         OUTMC(rinfo, ixR300_MC_IMP_CNTL_0, rinfo->save_regs[71]);
1607         OUTMC(rinfo, ixR300_MC_ELPIDA_CNTL, rinfo->save_regs[72]);
1608         OUTMC(rinfo, ixR300_MC_READ_CNTL_CD, rinfo->save_regs[96]);
1609         OUTREG(MC_IND_INDEX, 0);
1610 }
1611
1612 static void radeon_reinitialize_M10(struct radeonfb_info *rinfo)
1613 {
1614         u32 tmp, i;
1615
1616         /* Restore a bunch of registers first */
1617         OUTREG(MC_AGP_LOCATION, rinfo->save_regs[32]);
1618         OUTREG(DISPLAY_BASE_ADDR, rinfo->save_regs[31]);
1619         OUTREG(CRTC2_DISPLAY_BASE_ADDR, rinfo->save_regs[33]);
1620         OUTREG(MC_FB_LOCATION, rinfo->save_regs[30]);
1621         OUTREG(OV0_BASE_ADDR, rinfo->save_regs[80]);
1622         OUTREG(CONFIG_MEMSIZE, rinfo->video_ram);
1623         OUTREG(BUS_CNTL, rinfo->save_regs[36]);
1624         OUTREG(BUS_CNTL1, rinfo->save_regs[14]);
1625         OUTREG(MPP_TB_CONFIG, rinfo->save_regs[37]);
1626         OUTREG(FCP_CNTL, rinfo->save_regs[38]);
1627         OUTREG(RBBM_CNTL, rinfo->save_regs[39]);
1628         OUTREG(DAC_CNTL, rinfo->save_regs[40]);
1629         OUTREG(DAC_MACRO_CNTL, (INREG(DAC_MACRO_CNTL) & ~0x6) | 8);
1630         OUTREG(DAC_MACRO_CNTL, (INREG(DAC_MACRO_CNTL) & ~0x6) | 8);
1631
1632         /* Hrm... */
1633         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) | DAC2_EXPAND_MODE);
1634
1635         /* Reset the PAD CTLR */
1636         radeon_pm_reset_pad_ctlr_strength(rinfo);
1637
1638         /* Some PLLs are Read & written identically in the trace here...
1639          * I suppose it's actually to switch them all off & reset,
1640          * let's assume off is what we want. I'm just doing that for all major PLLs now.
1641          */
1642         radeon_pm_all_ppls_off(rinfo);
1643
1644         /* Clear tiling, reset swappers */
1645         INREG(SURFACE_CNTL);
1646         OUTREG(SURFACE_CNTL, 0);
1647
1648         /* Some black magic with TV_DAC_CNTL, we should restore those from backups
1649          * rather than hard coding...
1650          */
1651         tmp = INREG(TV_DAC_CNTL) & ~TV_DAC_CNTL_BGADJ_MASK;
1652         tmp |= 8 << TV_DAC_CNTL_BGADJ__SHIFT;
1653         OUTREG(TV_DAC_CNTL, tmp);
1654
1655         tmp = INREG(TV_DAC_CNTL) & ~TV_DAC_CNTL_DACADJ_MASK;
1656         tmp |= 7 << TV_DAC_CNTL_DACADJ__SHIFT;
1657         OUTREG(TV_DAC_CNTL, tmp);
1658
1659         /* More registers restored */
1660         OUTREG(AGP_CNTL, rinfo->save_regs[16]);
1661         OUTREG(HOST_PATH_CNTL, rinfo->save_regs[41]);
1662         OUTREG(DISP_MISC_CNTL, rinfo->save_regs[9]);
1663
1664         /* Hrmmm ... What is that ? */
1665         tmp = rinfo->save_regs[1]
1666                 & ~(CLK_PWRMGT_CNTL__ACTIVE_HILO_LAT_MASK |
1667                     CLK_PWRMGT_CNTL__MC_BUSY);
1668         OUTPLL(pllCLK_PWRMGT_CNTL, tmp);
1669
1670         OUTREG(PAD_CTLR_MISC, rinfo->save_regs[56]);
1671         OUTREG(FW_CNTL, rinfo->save_regs[57]);
1672         OUTREG(HDP_DEBUG, rinfo->save_regs[96]);
1673         OUTREG(PAMAC0_DLY_CNTL, rinfo->save_regs[54]);
1674         OUTREG(PAMAC1_DLY_CNTL, rinfo->save_regs[55]);
1675         OUTREG(PAMAC2_DLY_CNTL, rinfo->save_regs[79]);
1676
1677         /* Restore Memory Controller configuration */
1678         radeon_pm_m10_reconfigure_mc(rinfo);
1679
1680         /* Make sure CRTC's dont touch memory */
1681         OUTREG(CRTC_GEN_CNTL, INREG(CRTC_GEN_CNTL)
1682                | CRTC_GEN_CNTL__CRTC_DISP_REQ_EN_B);
1683         OUTREG(CRTC2_GEN_CNTL, INREG(CRTC2_GEN_CNTL)
1684                | CRTC2_GEN_CNTL__CRTC2_DISP_REQ_EN_B);
1685         mdelay(30);
1686
1687         /* Disable SDRAM refresh */
1688         OUTREG(MEM_REFRESH_CNTL, INREG(MEM_REFRESH_CNTL)
1689                | MEM_REFRESH_CNTL__MEM_REFRESH_DIS);
1690
1691         /* Restore XTALIN routing (CLK_PIN_CNTL) */
1692         OUTPLL(pllCLK_PIN_CNTL, rinfo->save_regs[4]);
1693
1694         /* Switch MCLK, YCLK and SCLK PLLs to PCI source & force them ON */
1695         tmp = rinfo->save_regs[2] & 0xff000000;
1696         tmp |=  MCLK_CNTL__FORCE_MCLKA |
1697                 MCLK_CNTL__FORCE_MCLKB |
1698                 MCLK_CNTL__FORCE_YCLKA |
1699                 MCLK_CNTL__FORCE_YCLKB |
1700                 MCLK_CNTL__FORCE_MC;
1701         OUTPLL(pllMCLK_CNTL, tmp);
1702
1703         /* Force all clocks on in SCLK */
1704         tmp = INPLL(pllSCLK_CNTL);
1705         tmp |=  SCLK_CNTL__FORCE_DISP2|
1706                 SCLK_CNTL__FORCE_CP|
1707                 SCLK_CNTL__FORCE_HDP|
1708                 SCLK_CNTL__FORCE_DISP1|
1709                 SCLK_CNTL__FORCE_TOP|
1710                 SCLK_CNTL__FORCE_E2|
1711                 SCLK_CNTL__FORCE_SE|
1712                 SCLK_CNTL__FORCE_IDCT|
1713                 SCLK_CNTL__FORCE_VIP|
1714                 SCLK_CNTL__FORCE_PB|
1715                 SCLK_CNTL__FORCE_TAM|
1716                 SCLK_CNTL__FORCE_TDM|
1717                 SCLK_CNTL__FORCE_RB|
1718                 SCLK_CNTL__FORCE_TV_SCLK|
1719                 SCLK_CNTL__FORCE_SUBPIC|
1720                 SCLK_CNTL__FORCE_OV0;
1721         tmp |=  SCLK_CNTL__CP_MAX_DYN_STOP_LAT  |
1722                 SCLK_CNTL__HDP_MAX_DYN_STOP_LAT |
1723                 SCLK_CNTL__TV_MAX_DYN_STOP_LAT  |
1724                 SCLK_CNTL__E2_MAX_DYN_STOP_LAT  |
1725                 SCLK_CNTL__SE_MAX_DYN_STOP_LAT  |
1726                 SCLK_CNTL__IDCT_MAX_DYN_STOP_LAT|
1727                 SCLK_CNTL__VIP_MAX_DYN_STOP_LAT |
1728                 SCLK_CNTL__RE_MAX_DYN_STOP_LAT  |
1729                 SCLK_CNTL__PB_MAX_DYN_STOP_LAT  |
1730                 SCLK_CNTL__TAM_MAX_DYN_STOP_LAT |
1731                 SCLK_CNTL__TDM_MAX_DYN_STOP_LAT |
1732                 SCLK_CNTL__RB_MAX_DYN_STOP_LAT;
1733         OUTPLL(pllSCLK_CNTL, tmp);
1734
1735         OUTPLL(pllVCLK_ECP_CNTL, 0);
1736         OUTPLL(pllPIXCLKS_CNTL, 0);
1737         OUTPLL(pllMCLK_MISC,
1738                MCLK_MISC__MC_MCLK_MAX_DYN_STOP_LAT |
1739                MCLK_MISC__IO_MCLK_MAX_DYN_STOP_LAT);
1740
1741         mdelay(5);
1742
1743         /* Restore the M_SPLL_REF_FB_DIV, MPLL_AUX_CNTL and SPLL_AUX_CNTL values */
1744         OUTPLL(pllM_SPLL_REF_FB_DIV, rinfo->save_regs[77]);
1745         OUTPLL(pllMPLL_AUX_CNTL, rinfo->save_regs[75]);
1746         OUTPLL(pllSPLL_AUX_CNTL, rinfo->save_regs[76]);
1747
1748         /* Now restore the major PLLs settings, keeping them off & reset though */
1749         OUTPLL(pllPPLL_CNTL, rinfo->save_regs[93] | 0x3);
1750         OUTPLL(pllP2PLL_CNTL, rinfo->save_regs[8] | 0x3);
1751         OUTPLL(pllMPLL_CNTL, rinfo->save_regs[73] | 0x03);
1752         OUTPLL(pllSPLL_CNTL, rinfo->save_regs[74] | 0x03);
1753
1754         /* Restore MC DLL state and switch it off/reset too  */
1755         OUTMC(rinfo, ixR300_MC_DLL_CNTL, rinfo->save_regs[70]);
1756
1757         /* Switch MDLL off & reset */
1758         OUTPLL(pllMDLL_RDCKA, rinfo->save_regs[98] | 0xff);
1759         mdelay(5);
1760
1761         /* Setup some black magic bits in PLL_PWRMGT_CNTL. Hrm... we saved
1762          * 0xa1100007... and MacOS writes 0xa1000007 ..
1763          */
1764         OUTPLL(pllPLL_PWRMGT_CNTL, rinfo->save_regs[0]);
1765
1766         /* Restore more stuffs */
1767         OUTPLL(pllHTOTAL_CNTL, 0);
1768         OUTPLL(pllHTOTAL2_CNTL, 0);
1769
1770         /* More PLL initial configuration */
1771         tmp = INPLL(pllSCLK_CNTL2); /* What for ? */
1772         OUTPLL(pllSCLK_CNTL2, tmp);
1773
1774         tmp = INPLL(pllSCLK_MORE_CNTL);
1775         tmp |=  SCLK_MORE_CNTL__FORCE_DISPREGS |        /* a guess */
1776                 SCLK_MORE_CNTL__FORCE_MC_GUI |
1777                 SCLK_MORE_CNTL__FORCE_MC_HOST;
1778         OUTPLL(pllSCLK_MORE_CNTL, tmp);
1779
1780         /* Now we actually start MCLK and SCLK */
1781         radeon_pm_start_mclk_sclk(rinfo);
1782
1783         /* Full reset sdrams, this also re-inits the MDLL */
1784         radeon_pm_full_reset_sdram(rinfo);
1785
1786         /* Fill palettes */
1787         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) | 0x20);
1788         for (i=0; i<256; i++)
1789                 OUTREG(PALETTE_30_DATA, 0x15555555);
1790         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) & ~20);
1791         udelay(20);
1792         for (i=0; i<256; i++)
1793                 OUTREG(PALETTE_30_DATA, 0x15555555);
1794
1795         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) & ~0x20);
1796         mdelay(3);
1797
1798         /* Restore TMDS */
1799         OUTREG(FP_GEN_CNTL, rinfo->save_regs[82]);
1800         OUTREG(FP2_GEN_CNTL, rinfo->save_regs[83]);
1801
1802         /* Set LVDS registers but keep interface & pll down */
1803         OUTREG(LVDS_GEN_CNTL, rinfo->save_regs[11] &
1804                ~(LVDS_EN | LVDS_ON | LVDS_DIGON | LVDS_BLON | LVDS_BL_MOD_EN));
1805         OUTREG(LVDS_PLL_CNTL, (rinfo->save_regs[12] & ~0xf0000) | 0x20000);
1806
1807         OUTREG(DISP_OUTPUT_CNTL, rinfo->save_regs[86]);
1808
1809         /* Restore GPIOPAD state */
1810         OUTREG(GPIOPAD_A, rinfo->save_regs[19]);
1811         OUTREG(GPIOPAD_EN, rinfo->save_regs[20]);
1812         OUTREG(GPIOPAD_MASK, rinfo->save_regs[21]);
1813
1814         /* write some stuff to the framebuffer... */
1815         for (i = 0; i < 0x8000; ++i)
1816                 writeb(0, rinfo->fb_base + i);
1817
1818         mdelay(40);
1819         OUTREG(LVDS_GEN_CNTL, INREG(LVDS_GEN_CNTL) | LVDS_DIGON | LVDS_ON);
1820         mdelay(40);
1821
1822         /* Restore a few more things */
1823         OUTREG(GRPH_BUFFER_CNTL, rinfo->save_regs[94]);
1824         OUTREG(GRPH2_BUFFER_CNTL, rinfo->save_regs[95]);
1825
1826         /* Take care of spread spectrum & PPLLs now */
1827         radeon_pm_m10_disable_spread_spectrum(rinfo);
1828         radeon_pm_restore_pixel_pll(rinfo);
1829
1830         /* GRRRR... I can't figure out the proper LVDS power sequence, and the
1831          * code I have for blank/unblank doesn't quite work on some laptop models
1832          * it seems ... Hrm. What I have here works most of the time ...
1833          */
1834         radeon_pm_m10_enable_lvds_spread_spectrum(rinfo);
1835 }
1836
1837 #ifdef CONFIG_PPC_OF
1838
1839 static void radeon_pm_m9p_reconfigure_mc(struct radeonfb_info *rinfo)
1840 {
1841         OUTREG(MC_CNTL, rinfo->save_regs[46]);
1842         OUTREG(MC_INIT_GFX_LAT_TIMER, rinfo->save_regs[47]);
1843         OUTREG(MC_INIT_MISC_LAT_TIMER, rinfo->save_regs[48]);
1844         OUTREG(MEM_SDRAM_MODE_REG,
1845                rinfo->save_regs[35] & ~MEM_SDRAM_MODE_REG__MC_INIT_COMPLETE);
1846         OUTREG(MC_TIMING_CNTL, rinfo->save_regs[49]);
1847         OUTREG(MC_READ_CNTL_AB, rinfo->save_regs[50]);
1848         OUTREG(MEM_REFRESH_CNTL, rinfo->save_regs[42]);
1849         OUTREG(MC_IOPAD_CNTL, rinfo->save_regs[51]);
1850         OUTREG(MC_DEBUG, rinfo->save_regs[53]);
1851         OUTREG(MC_CHIP_IO_OE_CNTL_AB, rinfo->save_regs[52]);
1852
1853         OUTMC(rinfo, ixMC_IMP_CNTL, rinfo->save_regs[59] /*0x00f460d6*/);
1854         OUTMC(rinfo, ixMC_CHP_IO_CNTL_A0, rinfo->save_regs[65] /*0xfecfa666*/);
1855         OUTMC(rinfo, ixMC_CHP_IO_CNTL_A1, rinfo->save_regs[66] /*0x141555ff*/);
1856         OUTMC(rinfo, ixMC_CHP_IO_CNTL_B0, rinfo->save_regs[67] /*0xfecfa666*/);
1857         OUTMC(rinfo, ixMC_CHP_IO_CNTL_B1, rinfo->save_regs[68] /*0x141555ff*/);
1858         OUTMC(rinfo, ixMC_IMP_CNTL_0, rinfo->save_regs[71] /*0x00009249*/);
1859         OUTREG(MC_IND_INDEX, 0);
1860         OUTREG(CONFIG_MEMSIZE, rinfo->video_ram);
1861
1862         mdelay(20);
1863 }
1864
1865 static void radeon_reinitialize_M9P(struct radeonfb_info *rinfo)
1866 {
1867         u32 tmp, i;
1868
1869         /* Restore a bunch of registers first */
1870         OUTREG(SURFACE_CNTL, rinfo->save_regs[29]);
1871         OUTREG(MC_AGP_LOCATION, rinfo->save_regs[32]);
1872         OUTREG(DISPLAY_BASE_ADDR, rinfo->save_regs[31]);
1873         OUTREG(CRTC2_DISPLAY_BASE_ADDR, rinfo->save_regs[33]);
1874         OUTREG(MC_FB_LOCATION, rinfo->save_regs[30]);
1875         OUTREG(OV0_BASE_ADDR, rinfo->save_regs[80]);
1876         OUTREG(BUS_CNTL, rinfo->save_regs[36]);
1877         OUTREG(BUS_CNTL1, rinfo->save_regs[14]);
1878         OUTREG(MPP_TB_CONFIG, rinfo->save_regs[37]);
1879         OUTREG(FCP_CNTL, rinfo->save_regs[38]);
1880         OUTREG(RBBM_CNTL, rinfo->save_regs[39]);
1881
1882         OUTREG(DAC_CNTL, rinfo->save_regs[40]);
1883         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) | DAC2_EXPAND_MODE);
1884
1885         /* Reset the PAD CTLR */
1886         radeon_pm_reset_pad_ctlr_strength(rinfo);
1887
1888         /* Some PLLs are Read & written identically in the trace here...
1889          * I suppose it's actually to switch them all off & reset,
1890          * let's assume off is what we want. I'm just doing that for all major PLLs now.
1891          */
1892         radeon_pm_all_ppls_off(rinfo);
1893
1894         /* Clear tiling, reset swappers */
1895         INREG(SURFACE_CNTL);
1896         OUTREG(SURFACE_CNTL, 0);
1897
1898         /* Some black magic with TV_DAC_CNTL, we should restore those from backups
1899          * rather than hard coding...
1900          */
1901         tmp = INREG(TV_DAC_CNTL) & ~TV_DAC_CNTL_BGADJ_MASK;
1902         tmp |= 6 << TV_DAC_CNTL_BGADJ__SHIFT;
1903         OUTREG(TV_DAC_CNTL, tmp);
1904
1905         tmp = INREG(TV_DAC_CNTL) & ~TV_DAC_CNTL_DACADJ_MASK;
1906         tmp |= 6 << TV_DAC_CNTL_DACADJ__SHIFT;
1907         OUTREG(TV_DAC_CNTL, tmp);
1908
1909         OUTPLL(pllAGP_PLL_CNTL, rinfo->save_regs[78]);
1910
1911         OUTREG(PAMAC0_DLY_CNTL, rinfo->save_regs[54]);
1912         OUTREG(PAMAC1_DLY_CNTL, rinfo->save_regs[55]);
1913         OUTREG(PAMAC2_DLY_CNTL, rinfo->save_regs[79]);
1914
1915         OUTREG(AGP_CNTL, rinfo->save_regs[16]);
1916         OUTREG(HOST_PATH_CNTL, rinfo->save_regs[41]); /* MacOS sets that to 0 !!! */
1917         OUTREG(DISP_MISC_CNTL, rinfo->save_regs[9]);
1918
1919         tmp  = rinfo->save_regs[1]
1920                 & ~(CLK_PWRMGT_CNTL__ACTIVE_HILO_LAT_MASK |
1921                     CLK_PWRMGT_CNTL__MC_BUSY);
1922         OUTPLL(pllCLK_PWRMGT_CNTL, tmp);
1923
1924         OUTREG(FW_CNTL, rinfo->save_regs[57]);
1925
1926         /* Disable SDRAM refresh */
1927         OUTREG(MEM_REFRESH_CNTL, INREG(MEM_REFRESH_CNTL)
1928                | MEM_REFRESH_CNTL__MEM_REFRESH_DIS);
1929
1930         /* Restore XTALIN routing (CLK_PIN_CNTL) */
1931         OUTPLL(pllCLK_PIN_CNTL, rinfo->save_regs[4]);
1932
1933         /* Force MCLK to be PCI sourced and forced ON */
1934         tmp = rinfo->save_regs[2] & 0xff000000;
1935         tmp |=  MCLK_CNTL__FORCE_MCLKA |
1936                 MCLK_CNTL__FORCE_MCLKB |
1937                 MCLK_CNTL__FORCE_YCLKA |
1938                 MCLK_CNTL__FORCE_YCLKB |
1939                 MCLK_CNTL__FORCE_MC    |
1940                 MCLK_CNTL__FORCE_AIC;
1941         OUTPLL(pllMCLK_CNTL, tmp);
1942
1943         /* Force SCLK to be PCI sourced with a bunch forced */
1944         tmp =   0 |
1945                 SCLK_CNTL__FORCE_DISP2|
1946                 SCLK_CNTL__FORCE_CP|
1947                 SCLK_CNTL__FORCE_HDP|
1948                 SCLK_CNTL__FORCE_DISP1|
1949                 SCLK_CNTL__FORCE_TOP|
1950                 SCLK_CNTL__FORCE_E2|
1951                 SCLK_CNTL__FORCE_SE|
1952                 SCLK_CNTL__FORCE_IDCT|
1953                 SCLK_CNTL__FORCE_VIP|
1954                 SCLK_CNTL__FORCE_RE|
1955                 SCLK_CNTL__FORCE_PB|
1956                 SCLK_CNTL__FORCE_TAM|
1957                 SCLK_CNTL__FORCE_TDM|
1958                 SCLK_CNTL__FORCE_RB;
1959         OUTPLL(pllSCLK_CNTL, tmp);
1960
1961         /* Clear VCLK_ECP_CNTL & PIXCLKS_CNTL  */
1962         OUTPLL(pllVCLK_ECP_CNTL, 0);
1963         OUTPLL(pllPIXCLKS_CNTL, 0);
1964
1965         /* Setup MCLK_MISC, non dynamic mode */
1966         OUTPLL(pllMCLK_MISC,
1967                MCLK_MISC__MC_MCLK_MAX_DYN_STOP_LAT |
1968                MCLK_MISC__IO_MCLK_MAX_DYN_STOP_LAT);
1969
1970         mdelay(5);
1971
1972         /* Set back the default clock dividers */
1973         OUTPLL(pllM_SPLL_REF_FB_DIV, rinfo->save_regs[77]);
1974         OUTPLL(pllMPLL_AUX_CNTL, rinfo->save_regs[75]);
1975         OUTPLL(pllSPLL_AUX_CNTL, rinfo->save_regs[76]);
1976
1977         /* PPLL and P2PLL default values & off */
1978         OUTPLL(pllPPLL_CNTL, rinfo->save_regs[93] | 0x3);
1979         OUTPLL(pllP2PLL_CNTL, rinfo->save_regs[8] | 0x3);
1980
1981         /* S and M PLLs are reset & off, configure them */
1982         OUTPLL(pllMPLL_CNTL, rinfo->save_regs[73] | 0x03);
1983         OUTPLL(pllSPLL_CNTL, rinfo->save_regs[74] | 0x03);
1984
1985         /* Default values for MDLL ... fixme */
1986         OUTPLL(pllMDLL_CKO, 0x9c009c);
1987         OUTPLL(pllMDLL_RDCKA, 0x08830883);
1988         OUTPLL(pllMDLL_RDCKB, 0x08830883);
1989         mdelay(5);
1990
1991         /* Restore PLL_PWRMGT_CNTL */ // XXXX
1992         tmp = rinfo->save_regs[0];
1993         tmp &= ~PLL_PWRMGT_CNTL_SU_SCLK_USE_BCLK;
1994         tmp |= PLL_PWRMGT_CNTL_SU_MCLK_USE_BCLK;
1995         OUTPLL(PLL_PWRMGT_CNTL,  tmp);
1996
1997         /* Clear HTOTAL_CNTL & HTOTAL2_CNTL */
1998         OUTPLL(pllHTOTAL_CNTL, 0);
1999         OUTPLL(pllHTOTAL2_CNTL, 0);
2000
2001         /* All outputs off */
2002         OUTREG(CRTC_GEN_CNTL, 0x04000000);
2003         OUTREG(CRTC2_GEN_CNTL, 0x04000000);
2004         OUTREG(FP_GEN_CNTL, 0x00004008);
2005         OUTREG(FP2_GEN_CNTL, 0x00000008);
2006         OUTREG(LVDS_GEN_CNTL, 0x08000008);
2007
2008         /* Restore Memory Controller configuration */
2009         radeon_pm_m9p_reconfigure_mc(rinfo);
2010
2011         /* Now we actually start MCLK and SCLK */
2012         radeon_pm_start_mclk_sclk(rinfo);
2013
2014         /* Full reset sdrams, this also re-inits the MDLL */
2015         radeon_pm_full_reset_sdram(rinfo);
2016
2017         /* Fill palettes */
2018         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) | 0x20);
2019         for (i=0; i<256; i++)
2020                 OUTREG(PALETTE_30_DATA, 0x15555555);
2021         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) & ~20);
2022         udelay(20);
2023         for (i=0; i<256; i++)
2024                 OUTREG(PALETTE_30_DATA, 0x15555555);
2025
2026         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) & ~0x20);
2027         mdelay(3);
2028
2029         /* Restore TV stuff, make sure TV DAC is down */
2030         OUTREG(TV_MASTER_CNTL, rinfo->save_regs[88]);
2031         OUTREG(TV_DAC_CNTL, rinfo->save_regs[13] | 0x07000000);
2032
2033         /* Restore GPIOS. MacOS does some magic here with one of the GPIO bits,
2034          * possibly related to the weird PLL related workarounds and to the
2035          * fact that CLK_PIN_CNTL is tweaked in ways I don't fully understand,
2036          * but we keep things the simple way here
2037          */
2038         OUTREG(GPIOPAD_A, rinfo->save_regs[19]);
2039         OUTREG(GPIOPAD_EN, rinfo->save_regs[20]);
2040         OUTREG(GPIOPAD_MASK, rinfo->save_regs[21]);
2041
2042         /* Now do things with SCLK_MORE_CNTL. Force bits are already set, copy
2043          * high bits from backup
2044          */
2045         tmp = INPLL(pllSCLK_MORE_CNTL) & 0x0000ffff;
2046         tmp |= rinfo->save_regs[34] & 0xffff0000;
2047         tmp |= SCLK_MORE_CNTL__FORCE_DISPREGS;
2048         OUTPLL(pllSCLK_MORE_CNTL, tmp);
2049
2050         tmp = INPLL(pllSCLK_MORE_CNTL) & 0x0000ffff;
2051         tmp |= rinfo->save_regs[34] & 0xffff0000;
2052         tmp |= SCLK_MORE_CNTL__FORCE_DISPREGS;
2053         OUTPLL(pllSCLK_MORE_CNTL, tmp);
2054
2055         OUTREG(LVDS_GEN_CNTL, rinfo->save_regs[11] &
2056                ~(LVDS_EN | LVDS_ON | LVDS_DIGON | LVDS_BLON | LVDS_BL_MOD_EN));
2057         OUTREG(LVDS_GEN_CNTL, INREG(LVDS_GEN_CNTL) | LVDS_BLON);
2058         OUTREG(LVDS_PLL_CNTL, (rinfo->save_regs[12] & ~0xf0000) | 0x20000);
2059         mdelay(20);
2060
2061         /* write some stuff to the framebuffer... */
2062         for (i = 0; i < 0x8000; ++i)
2063                 writeb(0, rinfo->fb_base + i);
2064
2065         OUTREG(0x2ec, 0x6332a020);
2066         OUTPLL(pllSSPLL_REF_DIV, rinfo->save_regs[44] /*0x3f */);
2067         OUTPLL(pllSSPLL_DIV_0, rinfo->save_regs[45] /*0x000081bb */);
2068         tmp = INPLL(pllSSPLL_CNTL);
2069         tmp &= ~2;
2070         OUTPLL(pllSSPLL_CNTL, tmp);
2071         mdelay(6);
2072         tmp &= ~1;
2073         OUTPLL(pllSSPLL_CNTL, tmp);
2074         mdelay(5);
2075         tmp |= 3;
2076         OUTPLL(pllSSPLL_CNTL, tmp);
2077         mdelay(5);
2078
2079         OUTPLL(pllSS_INT_CNTL, rinfo->save_regs[90] & ~3);/*0x0020300c*/
2080         OUTREG(0x2ec, 0x6332a3f0);
2081         mdelay(17);
2082
2083         OUTPLL(pllPPLL_REF_DIV, rinfo->pll.ref_div);
2084         OUTPLL(pllPPLL_DIV_0, rinfo->save_regs[92]);
2085
2086         mdelay(40);
2087         OUTREG(LVDS_GEN_CNTL, INREG(LVDS_GEN_CNTL) | LVDS_DIGON | LVDS_ON);
2088         mdelay(40);
2089
2090         /* Restore a few more things */
2091         OUTREG(GRPH_BUFFER_CNTL, rinfo->save_regs[94]);
2092         OUTREG(GRPH2_BUFFER_CNTL, rinfo->save_regs[95]);
2093
2094         /* Restore PPLL, spread spectrum & LVDS */
2095         radeon_pm_m10_disable_spread_spectrum(rinfo);
2096         radeon_pm_restore_pixel_pll(rinfo);
2097         radeon_pm_m10_enable_lvds_spread_spectrum(rinfo);
2098 }
2099
2100 #if 0 /* Not ready yet */
2101 static void radeon_reinitialize_QW(struct radeonfb_info *rinfo)
2102 {
2103         int i;
2104         u32 tmp, tmp2;
2105         u32 cko, cka, ckb;
2106         u32 cgc, cec, c2gc;
2107
2108         OUTREG(MC_AGP_LOCATION, rinfo->save_regs[32]);
2109         OUTREG(DISPLAY_BASE_ADDR, rinfo->save_regs[31]);
2110         OUTREG(CRTC2_DISPLAY_BASE_ADDR, rinfo->save_regs[33]);
2111         OUTREG(MC_FB_LOCATION, rinfo->save_regs[30]);
2112         OUTREG(BUS_CNTL, rinfo->save_regs[36]);
2113         OUTREG(RBBM_CNTL, rinfo->save_regs[39]);
2114
2115         INREG(PAD_CTLR_STRENGTH);
2116         OUTREG(PAD_CTLR_STRENGTH, INREG(PAD_CTLR_STRENGTH) & ~0x10000);
2117         for (i = 0; i < 65; ++i) {
2118                 mdelay(1);
2119                 INREG(PAD_CTLR_STRENGTH);
2120         }
2121
2122         OUTREG(DISP_TEST_DEBUG_CNTL, INREG(DISP_TEST_DEBUG_CNTL) | 0x10000000);
2123         OUTREG(OV0_FLAG_CNTRL, INREG(OV0_FLAG_CNTRL) | 0x100);
2124         OUTREG(CRTC_GEN_CNTL, INREG(CRTC_GEN_CNTL));
2125         OUTREG(DAC_CNTL, 0xff00410a);
2126         OUTREG(CRTC2_GEN_CNTL, INREG(CRTC2_GEN_CNTL));
2127         OUTREG(DAC_CNTL2, INREG(DAC_CNTL2) | 0x4000);
2128
2129         OUTREG(SURFACE_CNTL, rinfo->save_regs[29]);
2130         OUTREG(AGP_CNTL, rinfo->save_regs[16]);
2131         OUTREG(HOST_PATH_CNTL, rinfo->save_regs[41]);
2132         OUTREG(DISP_MISC_CNTL, rinfo->save_regs[9]);
2133
2134         OUTMC(rinfo, ixMC_CHP_IO_CNTL_A0, 0xf7bb4433);
2135         OUTREG(MC_IND_INDEX, 0);
2136         OUTMC(rinfo, ixMC_CHP_IO_CNTL_B0, 0xf7bb4433);
2137         OUTREG(MC_IND_INDEX, 0);
2138
2139         OUTREG(CRTC_MORE_CNTL, INREG(CRTC_MORE_CNTL));
2140
2141         tmp = INPLL(pllVCLK_ECP_CNTL);
2142         OUTPLL(pllVCLK_ECP_CNTL, tmp);
2143         tmp = INPLL(pllPIXCLKS_CNTL);
2144         OUTPLL(pllPIXCLKS_CNTL, tmp);
2145
2146         OUTPLL(MCLK_CNTL, 0xaa3f0000);
2147         OUTPLL(SCLK_CNTL, 0xffff0000);
2148         OUTPLL(pllMPLL_AUX_CNTL, 6);
2149         OUTPLL(pllSPLL_AUX_CNTL, 1);
2150         OUTPLL(MDLL_CKO, 0x9f009f);
2151         OUTPLL(MDLL_RDCKA, 0x830083);
2152         OUTPLL(pllMDLL_RDCKB, 0x830083);
2153         OUTPLL(PPLL_CNTL, 0xa433);
2154         OUTPLL(P2PLL_CNTL, 0xa433);
2155         OUTPLL(MPLL_CNTL, 0x0400a403);
2156         OUTPLL(SPLL_CNTL, 0x0400a433);
2157
2158         tmp = INPLL(M_SPLL_REF_FB_DIV);
2159         OUTPLL(M_SPLL_REF_FB_DIV, tmp);
2160         tmp = INPLL(M_SPLL_REF_FB_DIV);
2161         OUTPLL(M_SPLL_REF_FB_DIV, tmp | 0xc);
2162         INPLL(M_SPLL_REF_FB_DIV);
2163
2164         tmp = INPLL(MPLL_CNTL);
2165         OUTREG8(CLOCK_CNTL_INDEX, MPLL_CNTL + PLL_WR_EN);
2166         radeon_pll_errata_after_index(rinfo);
2167         OUTREG8(CLOCK_CNTL_DATA + 1, (tmp >> 8) & 0xff);
2168         radeon_pll_errata_after_data(rinfo);
2169
2170         tmp = INPLL(M_SPLL_REF_FB_DIV);
2171         OUTPLL(M_SPLL_REF_FB_DIV, tmp | 0x5900);
2172
2173         tmp = INPLL(MPLL_CNTL);
2174         OUTPLL(MPLL_CNTL, tmp & ~0x2);
2175         mdelay(1);
2176         tmp = INPLL(MPLL_CNTL);
2177         OUTPLL(MPLL_CNTL, tmp & ~0x1);
2178         mdelay(10);
2179
2180         OUTPLL(MCLK_CNTL, 0xaa3f1212);
2181         mdelay(1);
2182
2183         INPLL(M_SPLL_REF_FB_DIV);
2184         INPLL(MCLK_CNTL);
2185         INPLL(M_SPLL_REF_FB_DIV);
2186
2187         tmp = INPLL(SPLL_CNTL);
2188         OUTREG8(CLOCK_CNTL_INDEX, SPLL_CNTL + PLL_WR_EN);
2189         radeon_pll_errata_after_index(rinfo);
2190         OUTREG8(CLOCK_CNTL_DATA + 1, (tmp >> 8) & 0xff);
2191         radeon_pll_errata_after_data(rinfo);
2192
2193         tmp = INPLL(M_SPLL_REF_FB_DIV);
2194         OUTPLL(M_SPLL_REF_FB_DIV, tmp | 0x780000);
2195
2196         tmp = INPLL(SPLL_CNTL);
2197         OUTPLL(SPLL_CNTL, tmp & ~0x1);
2198         mdelay(1);
2199         tmp = INPLL(SPLL_CNTL);
2200         OUTPLL(SPLL_CNTL, tmp & ~0x2);
2201         mdelay(10);
2202
2203         tmp = INPLL(SCLK_CNTL);
2204         OUTPLL(SCLK_CNTL, tmp | 2);
2205         mdelay(1);
2206
2207         cko = INPLL(pllMDLL_CKO);
2208         cka = INPLL(pllMDLL_RDCKA);
2209         ckb = INPLL(pllMDLL_RDCKB);
2210
2211         cko &= ~(MDLL_CKO__MCKOA_SLEEP | MDLL_CKO__MCKOB_SLEEP);
2212         OUTPLL(pllMDLL_CKO, cko);
2213         mdelay(1);
2214         cko &= ~(MDLL_CKO__MCKOA_RESET | MDLL_CKO__MCKOB_RESET);
2215         OUTPLL(pllMDLL_CKO, cko);
2216         mdelay(5);
2217
2218         cka &= ~(MDLL_RDCKA__MRDCKA0_SLEEP | MDLL_RDCKA__MRDCKA1_SLEEP);
2219         OUTPLL(pllMDLL_RDCKA, cka);
2220         mdelay(1);
2221         cka &= ~(MDLL_RDCKA__MRDCKA0_RESET | MDLL_RDCKA__MRDCKA1_RESET);
2222         OUTPLL(pllMDLL_RDCKA, cka);
2223         mdelay(5);
2224
2225         ckb &= ~(MDLL_RDCKB__MRDCKB0_SLEEP | MDLL_RDCKB__MRDCKB1_SLEEP);
2226         OUTPLL(pllMDLL_RDCKB, ckb);
2227         mdelay(1);
2228         ckb &= ~(MDLL_RDCKB__MRDCKB0_RESET | MDLL_RDCKB__MRDCKB1_RESET);
2229         OUTPLL(pllMDLL_RDCKB, ckb);
2230         mdelay(5);
2231
2232         OUTMC(rinfo, ixMC_CHP_IO_CNTL_A1, 0x151550ff);
2233         OUTREG(MC_IND_INDEX, 0);
2234         OUTMC(rinfo, ixMC_CHP_IO_CNTL_B1, 0x151550ff);
2235         OUTREG(MC_IND_INDEX, 0);
2236         mdelay(1);
2237         OUTMC(rinfo, ixMC_CHP_IO_CNTL_A1, 0x141550ff);
2238         OUTREG(MC_IND_INDEX, 0);
2239         OUTMC(rinfo, ixMC_CHP_IO_CNTL_B1, 0x141550ff);
2240         OUTREG(MC_IND_INDEX, 0);
2241         mdelay(1);
2242
2243         OUTPLL(pllHTOTAL_CNTL, 0);
2244         OUTPLL(pllHTOTAL2_CNTL, 0);
2245
2246         OUTREG(MEM_CNTL, 0x29002901);
2247         OUTREG(MEM_SDRAM_MODE_REG, 0x45320032); /* XXX use save_regs[35]? */
2248         OUTREG(EXT_MEM_CNTL, 0x1a394333);
2249         OUTREG(MEM_IO_CNTL_A1, 0x0aac0aac);
2250         OUTREG(MEM_INIT_LATENCY_TIMER, 0x34444444);
2251         OUTREG(MEM_REFRESH_CNTL, 0x1f1f7218);   /* XXX or save_regs[42]? */
2252         OUTREG(MC_DEBUG, 0);
2253         OUTREG(MEM_IO_OE_CNTL, 0x04300430);
2254
2255         OUTMC(rinfo, ixMC_IMP_CNTL, 0x00f460d6);
2256         OUTREG(MC_IND_INDEX, 0);
2257         OUTMC(rinfo, ixMC_IMP_CNTL_0, 0x00009249);
2258         OUTREG(MC_IND_INDEX, 0);
2259
2260         OUTREG(CONFIG_MEMSIZE, rinfo->video_ram);
2261
2262         radeon_pm_full_reset_sdram(rinfo);
2263
2264         INREG(FP_GEN_CNTL);
2265         OUTREG(TMDS_CNTL, 0x01000000);  /* XXX ? */
2266         tmp = INREG(FP_GEN_CNTL);
2267         tmp |= FP_CRTC_DONT_SHADOW_HEND | FP_CRTC_DONT_SHADOW_VPAR | 0x200;
2268         OUTREG(FP_GEN_CNTL, tmp);
2269
2270         tmp = INREG(DISP_OUTPUT_CNTL);
2271         tmp &= ~0x400;
2272         OUTREG(DISP_OUTPUT_CNTL, tmp);
2273
2274         OUTPLL(CLK_PIN_CNTL, rinfo->save_regs[4]);
2275         OUTPLL(CLK_PWRMGT_CNTL, rinfo->save_regs[1]);
2276         OUTPLL(PLL_PWRMGT_CNTL, rinfo->save_regs[0]);
2277
2278         tmp = INPLL(MCLK_MISC);
2279         tmp |= MCLK_MISC__MC_MCLK_DYN_ENABLE | MCLK_MISC__IO_MCLK_DYN_ENABLE;
2280         OUTPLL(MCLK_MISC, tmp);
2281
2282         tmp = INPLL(SCLK_CNTL);
2283         OUTPLL(SCLK_CNTL, tmp);
2284
2285         OUTREG(CRTC_MORE_CNTL, 0);
2286         OUTREG8(CRTC_GEN_CNTL+1, 6);
2287         OUTREG8(CRTC_GEN_CNTL+3, 1);
2288         OUTREG(CRTC_PITCH, 32);
2289
2290         tmp = INPLL(VCLK_ECP_CNTL);
2291         OUTPLL(VCLK_ECP_CNTL, tmp);
2292
2293         tmp = INPLL(PPLL_CNTL);
2294         OUTPLL(PPLL_CNTL, tmp);
2295
2296         /* palette stuff and BIOS_1_SCRATCH... */
2297
2298         tmp = INREG(FP_GEN_CNTL);
2299         tmp2 = INREG(TMDS_TRANSMITTER_CNTL);
2300         tmp |= 2;
2301         OUTREG(FP_GEN_CNTL, tmp);
2302         mdelay(5);
2303         OUTREG(FP_GEN_CNTL, tmp);
2304         mdelay(5);
2305         OUTREG(TMDS_TRANSMITTER_CNTL, tmp2);
2306         OUTREG(CRTC_MORE_CNTL, 0);
2307         mdelay(20);
2308
2309         tmp = INREG(CRTC_MORE_CNTL);
2310         OUTREG(CRTC_MORE_CNTL, tmp);
2311
2312         cgc = INREG(CRTC_GEN_CNTL);
2313         cec = INREG(CRTC_EXT_CNTL);
2314         c2gc = INREG(CRTC2_GEN_CNTL);
2315
2316         OUTREG(CRTC_H_SYNC_STRT_WID, 0x008e0580);
2317         OUTREG(CRTC_H_TOTAL_DISP, 0x009f00d2);
2318         OUTREG8(CLOCK_CNTL_INDEX, HTOTAL_CNTL + PLL_WR_EN);
2319         radeon_pll_errata_after_index(rinfo);
2320         OUTREG8(CLOCK_CNTL_DATA, 0);
2321         radeon_pll_errata_after_data(rinfo);
2322         OUTREG(CRTC_V_SYNC_STRT_WID, 0x00830403);
2323         OUTREG(CRTC_V_TOTAL_DISP, 0x03ff0429);
2324         OUTREG(FP_CRTC_H_TOTAL_DISP, 0x009f0033);
2325         OUTREG(FP_H_SYNC_STRT_WID, 0x008e0080);
2326         OUTREG(CRT_CRTC_H_SYNC_STRT_WID, 0x008e0080);
2327         OUTREG(FP_CRTC_V_TOTAL_DISP, 0x03ff002a);
2328         OUTREG(FP_V_SYNC_STRT_WID, 0x00830004);
2329         OUTREG(CRT_CRTC_V_SYNC_STRT_WID, 0x00830004);
2330         OUTREG(FP_HORZ_VERT_ACTIVE, 0x009f03ff);
2331         OUTREG(FP_HORZ_STRETCH, 0);
2332         OUTREG(FP_VERT_STRETCH, 0);
2333         OUTREG(OVR_CLR, 0);
2334         OUTREG(OVR_WID_LEFT_RIGHT, 0);
2335         OUTREG(OVR_WID_TOP_BOTTOM, 0);
2336
2337         tmp = INPLL(PPLL_REF_DIV);
2338         tmp = (tmp & ~PPLL_REF_DIV_MASK) | rinfo->pll.ref_div;
2339         OUTPLL(PPLL_REF_DIV, tmp);
2340         INPLL(PPLL_REF_DIV);
2341
2342         OUTREG8(CLOCK_CNTL_INDEX, PPLL_CNTL + PLL_WR_EN);
2343         radeon_pll_errata_after_index(rinfo);
2344         OUTREG8(CLOCK_CNTL_DATA + 1, 0xbc);
2345         radeon_pll_errata_after_data(rinfo);
2346
2347         tmp = INREG(CLOCK_CNTL_INDEX);
2348         radeon_pll_errata_after_index(rinfo);
2349         OUTREG(CLOCK_CNTL_INDEX, tmp & 0xff);
2350         radeon_pll_errata_after_index(rinfo);
2351         radeon_pll_errata_after_data(rinfo);
2352
2353         OUTPLL(PPLL_DIV_0, 0x48090);
2354
2355         tmp = INPLL(PPLL_CNTL);
2356         OUTPLL(PPLL_CNTL, tmp & ~0x2);
2357         mdelay(1);
2358         tmp = INPLL(PPLL_CNTL);
2359         OUTPLL(PPLL_CNTL, tmp & ~0x1);
2360         mdelay(10);
2361
2362         tmp = INPLL(VCLK_ECP_CNTL);
2363         OUTPLL(VCLK_ECP_CNTL, tmp | 3);
2364         mdelay(1);
2365
2366         tmp = INPLL(VCLK_ECP_CNTL);
2367         OUTPLL(VCLK_ECP_CNTL, tmp);
2368
2369         c2gc |= CRTC2_DISP_REQ_EN_B;
2370         OUTREG(CRTC2_GEN_CNTL, c2gc);
2371         cgc |= CRTC_EN;
2372         OUTREG(CRTC_GEN_CNTL, cgc);
2373         OUTREG(CRTC_EXT_CNTL, cec);
2374         OUTREG(CRTC_PITCH, 0xa0);
2375         OUTREG(CRTC_OFFSET, 0);
2376         OUTREG(CRTC_OFFSET_CNTL, 0);
2377
2378         OUTREG(GRPH_BUFFER_CNTL, 0x20117c7c);
2379         OUTREG(GRPH2_BUFFER_CNTL, 0x00205c5c);
2380
2381         tmp2 = INREG(FP_GEN_CNTL);
2382         tmp = INREG(TMDS_TRANSMITTER_CNTL);
2383         OUTREG(0x2a8, 0x0000061b);
2384         tmp |= TMDS_PLL_EN;
2385         OUTREG(TMDS_TRANSMITTER_CNTL, tmp);
2386         mdelay(1);
2387         tmp &= ~TMDS_PLLRST;
2388         OUTREG(TMDS_TRANSMITTER_CNTL, tmp);
2389         tmp2 &= ~2;
2390         tmp2 |= FP_TMDS_EN;
2391         OUTREG(FP_GEN_CNTL, tmp2);
2392         mdelay(5);
2393         tmp2 |= FP_FPON;
2394         OUTREG(FP_GEN_CNTL, tmp2);
2395
2396         OUTREG(CUR_HORZ_VERT_OFF, CUR_LOCK | 1);
2397         cgc = INREG(CRTC_GEN_CNTL);
2398         OUTREG(CUR_HORZ_VERT_POSN, 0xbfff0fff);
2399         cgc |= 0x10000;
2400         OUTREG(CUR_OFFSET, 0);
2401 }
2402 #endif /* 0 */
2403
2404 #endif /* CONFIG_PPC_OF */
2405
2406 static void radeon_set_suspend(struct radeonfb_info *rinfo, int suspend)
2407 {
2408         u16 pwr_cmd;
2409         u32 tmp;
2410         int i;
2411
2412         if (!rinfo->pm_reg)
2413                 return;
2414
2415         /* Set the chip into appropriate suspend mode (we use D2,
2416          * D3 would require a compete re-initialization of the chip,
2417          * including PCI config registers, clocks, AGP conf, ...)
2418          */
2419         if (suspend) {
2420                 printk(KERN_DEBUG "radeonfb (%s): switching to D2 state...\n",
2421                        pci_name(rinfo->pdev));
2422
2423                 /* Disable dynamic power management of clocks for the
2424                  * duration of the suspend/resume process
2425                  */
2426                 radeon_pm_disable_dynamic_mode(rinfo);
2427
2428                 /* Save some registers */
2429                 radeon_pm_save_regs(rinfo, 0);
2430
2431                 /* Prepare mobility chips for suspend.
2432                  */
2433                 if (rinfo->is_mobility) {
2434                         /* Program V2CLK */
2435                         radeon_pm_program_v2clk(rinfo);
2436
2437                         /* Disable IO PADs */
2438                         radeon_pm_disable_iopad(rinfo);
2439
2440                         /* Set low current */
2441                         radeon_pm_low_current(rinfo);
2442
2443                         /* Prepare chip for power management */
2444                         radeon_pm_setup_for_suspend(rinfo);
2445
2446                         if (rinfo->family <= CHIP_FAMILY_RV280) {
2447                                 /* Reset the MDLL */
2448                                 /* because both INPLL and OUTPLL take the same
2449                                  * lock, that's why. */
2450                                 tmp = INPLL( pllMDLL_CKO) | MDLL_CKO__MCKOA_RESET
2451                                         | MDLL_CKO__MCKOB_RESET;
2452                                 OUTPLL( pllMDLL_CKO, tmp );
2453                         }
2454                 }
2455
2456                 for (i = 0; i < 64; ++i)
2457                         pci_read_config_dword(rinfo->pdev, i * 4,
2458                                               &rinfo->cfg_save[i]);
2459
2460                 /* Switch PCI power managment to D2. */
2461                 pci_disable_device(rinfo->pdev);
2462                 for (;;) {
2463                         pci_read_config_word(
2464                                 rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL,
2465                                 &pwr_cmd);
2466                         if (pwr_cmd & 2)
2467                                 break;
2468                         pci_write_config_word(
2469                                 rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL,
2470                                 (pwr_cmd & ~PCI_PM_CTRL_STATE_MASK) | 2);
2471                         mdelay(500);
2472                 }
2473         } else {
2474                 printk(KERN_DEBUG "radeonfb (%s): switching to D0 state...\n",
2475                        pci_name(rinfo->pdev));
2476
2477                 /* Switch back PCI powermanagment to D0 */
2478                 mdelay(200);
2479                 pci_write_config_word(rinfo->pdev, rinfo->pm_reg+PCI_PM_CTRL, 0);
2480                 mdelay(500);
2481
2482                 if (rinfo->family <= CHIP_FAMILY_RV250) {
2483                         /* Reset the SDRAM controller  */
2484                         radeon_pm_full_reset_sdram(rinfo);
2485
2486                         /* Restore some registers */
2487                         radeon_pm_restore_regs(rinfo);
2488                 } else {
2489                         /* Restore registers first */
2490                         radeon_pm_restore_regs(rinfo);
2491                         /* init sdram controller */
2492                         radeon_pm_full_reset_sdram(rinfo);
2493                 }
2494         }
2495 }
2496
2497 static int radeon_restore_pci_cfg(struct radeonfb_info *rinfo)
2498 {
2499         int i;
2500         static u32 radeon_cfg_after_resume[64];
2501
2502         for (i = 0; i < 64; ++i)
2503                 pci_read_config_dword(rinfo->pdev, i * 4,
2504                                       &radeon_cfg_after_resume[i]);
2505
2506         if (radeon_cfg_after_resume[PCI_BASE_ADDRESS_0/4]
2507             == rinfo->cfg_save[PCI_BASE_ADDRESS_0/4])
2508                 return 0;       /* assume everything is ok */
2509
2510         for (i = PCI_BASE_ADDRESS_0/4; i < 64; ++i) {
2511                 if (radeon_cfg_after_resume[i] != rinfo->cfg_save[i])
2512                         pci_write_config_dword(rinfo->pdev, i * 4,
2513                                                rinfo->cfg_save[i]);
2514         }
2515         pci_write_config_word(rinfo->pdev, PCI_CACHE_LINE_SIZE,
2516                               rinfo->cfg_save[PCI_CACHE_LINE_SIZE/4]);
2517         pci_write_config_word(rinfo->pdev, PCI_COMMAND,
2518                               rinfo->cfg_save[PCI_COMMAND/4]);
2519         return 1;
2520 }
2521
2522
2523 int radeonfb_pci_suspend(struct pci_dev *pdev, pm_message_t state)
2524 {
2525         struct fb_info *info = pci_get_drvdata(pdev);
2526         struct radeonfb_info *rinfo = info->par;
2527         int i;
2528
2529         if (state.event == pdev->dev.power.power_state.event)
2530                 return 0;
2531
2532         printk(KERN_DEBUG "radeonfb (%s): suspending to state: %d...\n",
2533                pci_name(pdev), state.event);
2534
2535         /* For suspend-to-disk, we cheat here. We don't suspend anything and
2536          * let fbcon continue drawing until we are all set. That shouldn't
2537          * really cause any problem at this point, provided that the wakeup
2538          * code knows that any state in memory may not match the HW
2539          */
2540         if (state.event == PM_EVENT_FREEZE)
2541                 goto done;
2542
2543         acquire_console_sem();
2544
2545         fb_set_suspend(info, 1);
2546
2547         if (!(info->flags & FBINFO_HWACCEL_DISABLED)) {
2548                 /* Make sure engine is reset */
2549                 radeon_engine_idle();
2550                 radeonfb_engine_reset(rinfo);
2551                 radeon_engine_idle();
2552         }
2553
2554         /* Blank display and LCD */
2555         radeon_screen_blank(rinfo, FB_BLANK_POWERDOWN, 1);
2556
2557         /* Sleep */
2558         rinfo->asleep = 1;
2559         rinfo->lock_blank = 1;
2560         del_timer_sync(&rinfo->lvds_timer);
2561
2562 #ifdef CONFIG_PPC_PMAC
2563         /* On powermac, we have hooks to properly suspend/resume AGP now,
2564          * use them here. We'll ultimately need some generic support here,
2565          * but the generic code isn't quite ready for that yet
2566          */
2567         pmac_suspend_agp_for_card(pdev);
2568 #endif /* CONFIG_PPC_PMAC */
2569
2570         /* If we support wakeup from poweroff, we save all regs we can including cfg
2571          * space
2572          */
2573         if (rinfo->pm_mode & radeon_pm_off) {
2574                 /* Always disable dynamic clocks or weird things are happening when
2575                  * the chip goes off (basically the panel doesn't shut down properly
2576                  * and we crash on wakeup),
2577                  * also, we want the saved regs context to have no dynamic clocks in
2578                  * it, we'll restore the dynamic clocks state on wakeup
2579                  */
2580                 radeon_pm_disable_dynamic_mode(rinfo);
2581                 mdelay(50);
2582                 radeon_pm_save_regs(rinfo, 1);
2583
2584                 if (rinfo->is_mobility && !(rinfo->pm_mode & radeon_pm_d2)) {
2585                         /* Switch off LVDS interface */
2586                         mdelay(1);
2587                         OUTREG(LVDS_GEN_CNTL, INREG(LVDS_GEN_CNTL) & ~(LVDS_BL_MOD_EN));
2588                         mdelay(1);
2589                         OUTREG(LVDS_GEN_CNTL, INREG(LVDS_GEN_CNTL) & ~(LVDS_EN | LVDS_ON));
2590                         OUTREG(LVDS_PLL_CNTL, (INREG(LVDS_PLL_CNTL) & ~30000) | 0x20000);
2591                         mdelay(20);
2592                         OUTREG(LVDS_GEN_CNTL, INREG(LVDS_GEN_CNTL) & ~(LVDS_DIGON));
2593                 }
2594                 // FIXME: Use PCI layer
2595                 for (i = 0; i < 64; ++i)
2596                         pci_read_config_dword(pdev, i * 4, &rinfo->cfg_save[i]);
2597                 pci_disable_device(pdev);
2598         }
2599         /* If we support D2, we go to it (should be fixed later with a flag forcing
2600          * D3 only for some laptops)
2601          */
2602         if (rinfo->pm_mode & radeon_pm_d2)
2603                 radeon_set_suspend(rinfo, 1);
2604
2605         release_console_sem();
2606
2607  done:
2608         pdev->dev.power.power_state = state;
2609
2610         return 0;
2611 }
2612
2613 int radeonfb_pci_resume(struct pci_dev *pdev)
2614 {
2615         struct fb_info *info = pci_get_drvdata(pdev);
2616         struct radeonfb_info *rinfo = info->par;
2617         int rc = 0;
2618
2619         if (pdev->dev.power.power_state.event == PM_EVENT_ON)
2620                 return 0;
2621
2622         if (rinfo->no_schedule) {
2623                 if (try_acquire_console_sem())
2624                         return 0;
2625         } else
2626                 acquire_console_sem();
2627
2628         printk(KERN_DEBUG "radeonfb (%s): resuming from state: %d...\n",
2629                pci_name(pdev), pdev->dev.power.power_state.event);
2630
2631
2632         if (pci_enable_device(pdev)) {
2633                 rc = -ENODEV;
2634                 printk(KERN_ERR "radeonfb (%s): can't enable PCI device !\n",
2635                        pci_name(pdev));
2636                 goto bail;
2637         }
2638         pci_set_master(pdev);
2639
2640         if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2641                 /* Wakeup chip. Check from config space if we were powered off
2642                  * (todo: additionally, check CLK_PIN_CNTL too)
2643                  */
2644                 if ((rinfo->pm_mode & radeon_pm_off) && radeon_restore_pci_cfg(rinfo)) {
2645                         if (rinfo->reinit_func != NULL)
2646                                 rinfo->reinit_func(rinfo);
2647                         else {
2648                                 printk(KERN_ERR "radeonfb (%s): can't resume radeon from"
2649                                        " D3 cold, need softboot !", pci_name(pdev));
2650                                 rc = -EIO;
2651                                 goto bail;
2652                         }
2653                 }
2654                 /* If we support D2, try to resume... we should check what was our
2655                  * state though... (were we really in D2 state ?). Right now, this code
2656                  * is only enable on Macs so it's fine.
2657                  */
2658                 else if (rinfo->pm_mode & radeon_pm_d2)
2659                         radeon_set_suspend(rinfo, 0);
2660
2661                 rinfo->asleep = 0;
2662         } else
2663                 radeon_engine_idle();
2664
2665         /* Restore display & engine */
2666         radeon_write_mode (rinfo, &rinfo->state, 1);
2667         if (!(info->flags & FBINFO_HWACCEL_DISABLED))
2668                 radeonfb_engine_init (rinfo);
2669
2670         fb_pan_display(info, &info->var);
2671         fb_set_cmap(&info->cmap, info);
2672
2673         /* Refresh */
2674         fb_set_suspend(info, 0);
2675
2676         /* Unblank */
2677         rinfo->lock_blank = 0;
2678         radeon_screen_blank(rinfo, FB_BLANK_UNBLANK, 1);
2679
2680 #ifdef CONFIG_PPC_PMAC
2681         /* On powermac, we have hooks to properly suspend/resume AGP now,
2682          * use them here. We'll ultimately need some generic support here,
2683          * but the generic code isn't quite ready for that yet
2684          */
2685         pmac_resume_agp_for_card(pdev);
2686 #endif /* CONFIG_PPC_PMAC */
2687
2688
2689         /* Check status of dynclk */
2690         if (rinfo->dynclk == 1)
2691                 radeon_pm_enable_dynamic_mode(rinfo);
2692         else if (rinfo->dynclk == 0)
2693                 radeon_pm_disable_dynamic_mode(rinfo);
2694
2695         pdev->dev.power.power_state = PMSG_ON;
2696
2697  bail:
2698         release_console_sem();
2699
2700         return rc;
2701 }
2702
2703 #ifdef CONFIG_PPC_OF
2704 static void radeonfb_early_resume(void *data)
2705 {
2706         struct radeonfb_info *rinfo = data;
2707
2708         rinfo->no_schedule = 1;
2709         radeonfb_pci_resume(rinfo->pdev);
2710         rinfo->no_schedule = 0;
2711 }
2712 #endif /* CONFIG_PPC_OF */
2713
2714 #endif /* CONFIG_PM */
2715
2716 void radeonfb_pm_init(struct radeonfb_info *rinfo, int dynclk)
2717 {
2718         /* Find PM registers in config space if any*/
2719         rinfo->pm_reg = pci_find_capability(rinfo->pdev, PCI_CAP_ID_PM);
2720
2721         /* Enable/Disable dynamic clocks: TODO add sysfs access */
2722         rinfo->dynclk = dynclk;
2723         if (dynclk == 1) {
2724                 radeon_pm_enable_dynamic_mode(rinfo);
2725                 printk("radeonfb: Dynamic Clock Power Management enabled\n");
2726         } else if (dynclk == 0) {
2727                 radeon_pm_disable_dynamic_mode(rinfo);
2728                 printk("radeonfb: Dynamic Clock Power Management disabled\n");
2729         }
2730
2731 #if defined(CONFIG_PM)
2732         /* Check if we can power manage on suspend/resume. We can do
2733          * D2 on M6, M7 and M9, and we can resume from D3 cold a few other
2734          * "Mac" cards, but that's all. We need more infos about what the
2735          * BIOS does tho. Right now, all this PM stuff is pmac-only for that
2736          * reason. --BenH
2737          */
2738         /* Special case for Samsung P35 laptops
2739          */
2740         if ((rinfo->pdev->vendor == PCI_VENDOR_ID_ATI) &&
2741             (rinfo->pdev->device == PCI_CHIP_RV350_NP) &&
2742             (rinfo->pdev->subsystem_vendor == PCI_VENDOR_ID_SAMSUNG) &&
2743             (rinfo->pdev->subsystem_device == 0xc00c)) {
2744                 rinfo->reinit_func = radeon_reinitialize_M10;
2745                 rinfo->pm_mode |= radeon_pm_off;
2746         }
2747 #if defined(CONFIG_PPC_PMAC)
2748         if (machine_is(powermac) && rinfo->of_node) {
2749                 if (rinfo->is_mobility && rinfo->pm_reg &&
2750                     rinfo->family <= CHIP_FAMILY_RV250)
2751                         rinfo->pm_mode |= radeon_pm_d2;
2752
2753                 /* We can restart Jasper (M10 chip in albooks), BlueStone (7500 chip
2754                  * in some desktop G4s), Via (M9+ chip on iBook G4) and
2755                  * Snowy (M11 chip on iBook G4 manufactured after July 2005)
2756                  */
2757                 if (!strcmp(rinfo->of_node->name, "ATY,JasperParent") ||
2758                     !strcmp(rinfo->of_node->name, "ATY,SnowyParent")) {
2759                         rinfo->reinit_func = radeon_reinitialize_M10;
2760                         rinfo->pm_mode |= radeon_pm_off;
2761                 }
2762 #if 0 /* Not ready yet */
2763                 if (!strcmp(rinfo->of_node->name, "ATY,BlueStoneParent")) {
2764                         rinfo->reinit_func = radeon_reinitialize_QW;
2765                         rinfo->pm_mode |= radeon_pm_off;
2766                 }
2767 #endif
2768                 if (!strcmp(rinfo->of_node->name, "ATY,ViaParent")) {
2769                         rinfo->reinit_func = radeon_reinitialize_M9P;
2770                         rinfo->pm_mode |= radeon_pm_off;
2771                 }
2772
2773                 /* If any of the above is set, we assume the machine can sleep/resume.
2774                  * It's a bit of a "shortcut" but will work fine. Ideally, we need infos
2775                  * from the platform about what happens to the chip...
2776                  * Now we tell the platform about our capability
2777                  */
2778                 if (rinfo->pm_mode != radeon_pm_none) {
2779                         pmac_call_feature(PMAC_FTR_DEVICE_CAN_WAKE, rinfo->of_node, 0, 1);
2780                         pmac_set_early_video_resume(radeonfb_early_resume, rinfo);
2781                 }
2782
2783 #if 0
2784                 /* Power down TV DAC, taht saves a significant amount of power,
2785                  * we'll have something better once we actually have some TVOut
2786                  * support
2787                  */
2788                 OUTREG(TV_DAC_CNTL, INREG(TV_DAC_CNTL) | 0x07000000);
2789 #endif
2790         }
2791 #endif /* defined(CONFIG_PPC_PMAC) */
2792 #endif /* defined(CONFIG_PM) */
2793 }
2794
2795 void radeonfb_pm_exit(struct radeonfb_info *rinfo)
2796 {
2797 #if defined(CONFIG_PM) && defined(CONFIG_PPC_PMAC)
2798         if (rinfo->pm_mode != radeon_pm_none)
2799                 pmac_set_early_video_resume(NULL, NULL);
2800 #endif
2801 }