shared-core/radeon_ms_gpu.c

   1 /*
   2  * Copyright 2007 Jérôme Glisse
   3  * Copyright 2007 Alex Deucher
   4  * Copyright 2007 Dave Airlie
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining
   8  * a copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation on the rights to use, copy, modify, merge,
  11  * publish, distribute, sublicense, and/or sell copies of the Software,
  12  * and to permit persons to whom the Software is furnished to do so,
  13  * subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial
  17  * portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22  * NON-INFRINGEMENT.  IN NO EVENT SHALL ATI, VA LINUX SYSTEMS AND/OR
  23  * THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26  * DEALINGS IN THE SOFTWARE.
  27  */
  28 #include "radeon_ms.h"
  29
  30 static int radeon_ms_gpu_address_space_init(struct drm_device *dev)
  31 {
  32         struct drm_radeon_private *dev_priv = dev->dev_private;
  33         struct radeon_state *state = &dev_priv->driver_state;
  34
  35         /* initialize gpu mapping */
  36         dev_priv->gpu_vram_start = dev_priv->vram.offset;
  37         dev_priv->gpu_vram_end = dev_priv->gpu_vram_start + dev_priv->vram.size;
  38         /* align it on 16Mo boundary (clamp memory which is then
  39          * unreachable but not manufacturer should use strange
  40          * memory size */
  41         dev_priv->gpu_vram_end = dev_priv->gpu_vram_end & (~0xFFFFFF);
  42         dev_priv->gpu_vram_end -= 1;
  43         dev_priv->gpu_vram_size = dev_priv->gpu_vram_end -
  44                                   dev_priv->gpu_vram_start + 1;
  45         /* set gart size to 32Mo FIXME: should make a parameter for this */
  46         dev_priv->gpu_gart_size = 1024 * 1024 * 32;
  47         if (dev_priv->gpu_gart_size > (0xffffffffU - dev_priv->gpu_vram_end)) {
  48                 /* align gart start to next 4Ko in gpu address space */
  49                 dev_priv->gpu_gart_start = (dev_priv->gpu_vram_end + 1) + 0xfff;
  50                 dev_priv->gpu_gart_start = dev_priv->gpu_gart_start & (~0xfff);
  51                 dev_priv->gpu_gart_end = dev_priv->gpu_gart_start +
  52                                          dev_priv->gpu_gart_size;
  53                 dev_priv->gpu_gart_end = (dev_priv->gpu_gart_end & (~0xfff)) -
  54                                          0x1000;
  55         } else {
  56                 /* align gart start to next 4Ko in gpu address space */
  57                 dev_priv->gpu_gart_start = (dev_priv->gpu_vram_start & ~0xfff) -
  58                                            dev_priv->gpu_gart_size;
  59                 dev_priv->gpu_gart_start = dev_priv->gpu_gart_start & (~0xfff);
  60                 dev_priv->gpu_gart_end = dev_priv->gpu_gart_start +
  61                                          dev_priv->gpu_gart_size;
  62                 dev_priv->gpu_gart_end = (dev_priv->gpu_gart_end & (~0xfff)) -
  63                                          0x1000;
  64         }
  65         state->mc_fb_location =
  66                 REG_S(MC_FB_LOCATION, MC_FB_START,
  67                                 dev_priv->gpu_vram_start >> 16) |
  68                 REG_S(MC_FB_LOCATION, MC_FB_TOP, dev_priv->gpu_vram_end >> 16);
  69         state->display_base_addr =
  70                 REG_S(DISPLAY_BASE_ADDR, DISPLAY_BASE_ADDR,
  71                                 dev_priv->gpu_vram_start);
  72         state->config_aper_0_base = dev_priv->gpu_vram_start;
  73         state->config_aper_1_base = dev_priv->gpu_vram_start;
  74         state->config_aper_size = dev_priv->gpu_vram_size;
  75         DRM_INFO("[radeon_ms] gpu vram start 0x%08X\n",
  76                  dev_priv->gpu_vram_start);
  77         DRM_INFO("[radeon_ms] gpu vram end   0x%08X\n",
  78                  dev_priv->gpu_vram_end);
  79         DRM_INFO("[radeon_ms] gpu gart start 0x%08X\n",
  80                  dev_priv->gpu_gart_start);
  81         DRM_INFO("[radeon_ms] gpu gart end   0x%08X\n",
  82                  dev_priv->gpu_gart_end);
  83         return 0;
  84 }
  85
  86 static void radeon_ms_gpu_reset(struct drm_device *dev)
  87 {
  88         struct drm_radeon_private *dev_priv = dev->dev_private;
  89         uint32_t clock_cntl_index, mclk_cntl, rbbm_soft_reset;
  90         uint32_t reset_mask, host_path_cntl, cache_mode;
  91
  92         radeon_ms_cp_stop(dev);
  93         radeon_ms_gpu_flush(dev);
  94
  95         /* reset clock */
  96         clock_cntl_index = MMIO_R(CLOCK_CNTL_INDEX);
  97         pll_index_errata(dev_priv);
  98         mclk_cntl = PPLL_R(MCLK_CNTL);
  99         PPLL_W(MCLK_CNTL,
 100                         mclk_cntl |
 101                         MCLK_CNTL__FORCE_MCLKA |
 102                         MCLK_CNTL__FORCE_MCLKB |
 103                         MCLK_CNTL__FORCE_YCLKA |
 104                         MCLK_CNTL__FORCE_YCLKB |
 105                         MCLK_CNTL__FORCE_MC |
 106                         MCLK_CNTL__FORCE_AIC);
 107         PPLL_W(SCLK_CNTL,
 108                         PPLL_R(SCLK_CNTL) |
 109                         SCLK_CNTL__FORCE_CP |
 110                         SCLK_CNTL__FORCE_VIP);
 111
 112         /* Soft resetting HDP thru RBBM_SOFT_RESET register can cause some
 113          * unexpected behaviour on some machines.  Here we use
 114          * RADEON_HOST_PATH_CNTL to reset it.
 115          */
 116         host_path_cntl = MMIO_R(HOST_PATH_CNTL);
 117         rbbm_soft_reset = MMIO_R(RBBM_SOFT_RESET);
 118         reset_mask = RBBM_SOFT_RESET__SOFT_RESET_CP |
 119                 RBBM_SOFT_RESET__SOFT_RESET_HI |
 120                 RBBM_SOFT_RESET__SOFT_RESET_VAP |
 121                 RBBM_SOFT_RESET__SOFT_RESET_SE |
 122                 RBBM_SOFT_RESET__SOFT_RESET_RE |
 123                 RBBM_SOFT_RESET__SOFT_RESET_PP |
 124                 RBBM_SOFT_RESET__SOFT_RESET_E2 |
 125                 RBBM_SOFT_RESET__SOFT_RESET_RB;
 126         MMIO_W(RBBM_SOFT_RESET, rbbm_soft_reset | reset_mask);
 127         MMIO_R(RBBM_SOFT_RESET);
 128         MMIO_W(RBBM_SOFT_RESET, 0);
 129         MMIO_R(RBBM_SOFT_RESET);
 130
 131 #if 1
 132         cache_mode = MMIO_R(RB2D_DSTCACHE_MODE);
 133         MMIO_W(RB2D_DSTCACHE_MODE,
 134                         cache_mode | RB2D_DSTCACHE_MODE__DC_DISABLE_IGNORE_PE);
 135 #else
 136         reset_mask = RBBM_SOFT_RESET__SOFT_RESET_CP |
 137                 RBBM_SOFT_RESET__SOFT_RESET_HI |
 138                 RBBM_SOFT_RESET__SOFT_RESET_E2;
 139         MMIO_W(RBBM_SOFT_RESET, rbbm_soft_reset | reset_mask);
 140         MMIO_R(RBBM_SOFT_RESET);
 141         MMIO_W(RBBM_SOFT_RESET, 0);
 142         cache_mode = MMIO_R(RB3D_DSTCACHE_CTLSTAT);
 143         MMIO_W(RB3D_DSTCACHE_CTLSTAT, cache_mode | (0xf));
 144 #endif
 145
 146         MMIO_W(HOST_PATH_CNTL, host_path_cntl | HOST_PATH_CNTL__HDP_SOFT_RESET);
 147         MMIO_R(HOST_PATH_CNTL);
 148         MMIO_W(HOST_PATH_CNTL, host_path_cntl);
 149         MMIO_R(HOST_PATH_CNTL);
 150
 151         MMIO_W(CLOCK_CNTL_INDEX, clock_cntl_index);
 152         pll_index_errata(dev_priv);
 153         PPLL_W(MCLK_CNTL, mclk_cntl);
 154 }
 155
 156 static void radeon_ms_gpu_resume(struct drm_device *dev)
 157 {
 158         struct drm_radeon_private *dev_priv = dev->dev_private;
 159         uint32_t a;
 160         uint32_t i;
 161
 162         /* make sure we have sane offset before restoring crtc */
 163         a = (MMIO_R(MC_FB_LOCATION) & MC_FB_LOCATION__MC_FB_START__MASK) << 16;
 164         MMIO_W(DISPLAY_BASE_ADDR, a);
 165         MMIO_W(CRTC2_DISPLAY_BASE_ADDR, a);
 166         MMIO_W(CRTC_OFFSET, 0);
 167         MMIO_W(CUR_OFFSET, 0);
 168         MMIO_W(CRTC_OFFSET_CNTL, CRTC_OFFSET_CNTL__CRTC_OFFSET_FLIP_CNTL);
 169         MMIO_W(CRTC2_OFFSET, 0);
 170         MMIO_W(CUR2_OFFSET, 0);
 171         MMIO_W(CRTC2_OFFSET_CNTL, CRTC2_OFFSET_CNTL__CRTC2_OFFSET_FLIP_CNTL);
 172         for (i = 0; i < dev_priv->usec_timeout; i++) {
 173                 if (!(CRTC_OFFSET__CRTC_GUI_TRIG_OFFSET &
 174                       MMIO_R(CRTC_OFFSET))) {
 175                         break;
 176                 }
 177                 DRM_UDELAY(1);
 178         }
 179         if (i >= dev_priv->usec_timeout) {
 180                 DRM_INFO("[radeon_ms] timeout waiting for crtc...\n");
 181         }
 182         for (i = 0; i < dev_priv->usec_timeout; i++) {
 183                 if (!(CRTC2_OFFSET__CRTC2_GUI_TRIG_OFFSET &
 184                       MMIO_R(CRTC2_OFFSET))) {
 185                         break;
 186                 }
 187                 DRM_UDELAY(1);
 188         }
 189         if (i >= dev_priv->usec_timeout) {
 190                 DRM_INFO("[radeon_ms] timeout waiting for crtc...\n");
 191         }
 192         DRM_UDELAY(10000);
 193 }
 194
 195 static void radeon_ms_gpu_stop(struct drm_device *dev)
 196 {
 197         struct drm_radeon_private *dev_priv = dev->dev_private;
 198         uint32_t ov0_scale_cntl, crtc_ext_cntl, crtc_gen_cntl;
 199         uint32_t crtc2_gen_cntl, i;
 200
 201         /* Capture MC_STATUS in case things go wrong ... */
 202         ov0_scale_cntl = dev_priv->ov0_scale_cntl = MMIO_R(OV0_SCALE_CNTL);
 203         crtc_ext_cntl = dev_priv->crtc_ext_cntl = MMIO_R(CRTC_EXT_CNTL);
 204         crtc_gen_cntl = dev_priv->crtc_gen_cntl = MMIO_R(CRTC_GEN_CNTL);
 205         crtc2_gen_cntl = dev_priv->crtc2_gen_cntl = MMIO_R(CRTC2_GEN_CNTL);
 206         ov0_scale_cntl &= ~OV0_SCALE_CNTL__OV0_OVERLAY_EN__MASK;
 207         crtc_ext_cntl |= CRTC_EXT_CNTL__CRTC_DISPLAY_DIS;
 208         crtc_gen_cntl &= ~CRTC_GEN_CNTL__CRTC_CUR_EN;
 209         crtc_gen_cntl &= ~CRTC_GEN_CNTL__CRTC_ICON_EN;
 210         crtc_gen_cntl |= CRTC_GEN_CNTL__CRTC_EXT_DISP_EN;
 211         crtc_gen_cntl |= CRTC_GEN_CNTL__CRTC_DISP_REQ_EN_B;
 212         crtc2_gen_cntl &= ~CRTC2_GEN_CNTL__CRTC2_CUR_EN;
 213         crtc2_gen_cntl &= ~CRTC2_GEN_CNTL__CRTC2_ICON_EN;
 214         crtc2_gen_cntl |= CRTC2_GEN_CNTL__CRTC2_DISP_REQ_EN_B;
 215         MMIO_W(OV0_SCALE_CNTL, ov0_scale_cntl);
 216         MMIO_W(CRTC_EXT_CNTL, crtc_ext_cntl);
 217         MMIO_W(CRTC_GEN_CNTL, crtc_gen_cntl);
 218         MMIO_W(CRTC2_GEN_CNTL, crtc2_gen_cntl);
 219         DRM_UDELAY(10000);
 220         switch (dev_priv->family) {
 221         case CHIP_R100:
 222         case CHIP_R200:
 223         case CHIP_RV200:
 224         case CHIP_RV250:
 225         case CHIP_RV280:
 226         case CHIP_RS300:
 227                 for (i = 0; i < dev_priv->usec_timeout; i++) {
 228                         if ((MC_STATUS__MC_IDLE & MMIO_R(MC_STATUS))) {
 229                                 DRM_INFO("[radeon_ms] gpu stoped in %d usecs\n",
 230                                          i);
 231                                 return;
 232                         }
 233                         DRM_UDELAY(1);
 234                 }
 235                 break;
 236         case CHIP_R300:
 237         case CHIP_R350:
 238         case CHIP_R360:
 239         case CHIP_RV350:
 240         case CHIP_RV370:
 241         case CHIP_RV380:
 242         case CHIP_RS400:
 243         case CHIP_RV410:
 244         case CHIP_R420:
 245         case CHIP_R430:
 246         case CHIP_R480:
 247                 for (i = 0; i < dev_priv->usec_timeout; i++) {
 248                         if ((MC_STATUS__MC_IDLE_R3 & MMIO_R(MC_STATUS))) {
 249                                 DRM_INFO("[radeon_ms] gpu stoped in %d usecs\n",
 250                                          i);
 251                                 return;
 252                         }
 253                         DRM_UDELAY(1);
 254                 }
 255                 break;
 256         default:
 257                 DRM_INFO("Unknown radeon family, aborting\n");
 258                 return;
 259         }
 260         DRM_INFO("[radeon_ms] failed to stop gpu...will proceed anyway\n");
 261         DRM_UDELAY(20000);
 262 }
 263
 264 static int radeon_ms_wait_for_fifo(struct drm_device *dev, int num_fifo)
 265 {
 266         struct drm_radeon_private *dev_priv = dev->dev_private;
 267         int i;
 268
 269         for (i = 0; i < dev_priv->usec_timeout; i++) {
 270                 int t;
 271                 t = RBBM_STATUS__CMDFIFO_AVAIL__MASK & MMIO_R(RBBM_STATUS);
 272                 t = t >> RBBM_STATUS__CMDFIFO_AVAIL__SHIFT;
 273                 if (t >= num_fifo)
 274                         return 0;
 275                 DRM_UDELAY(1);
 276         }
 277         DRM_INFO("[radeon_ms] failed to wait for fifo\n");
 278         return -EBUSY;
 279 }
 280
 281 int radeon_ms_gpu_initialize(struct drm_device *dev)
 282 {
 283         struct drm_radeon_private *dev_priv = dev->dev_private;
 284         struct radeon_state *state = &dev_priv->driver_state;
 285         int ret;
 286
 287         state->disp_misc_cntl = DISP_MISC_CNTL__SYNC_PAD_FLOP_EN |
 288                 REG_S(DISP_MISC_CNTL, SYNC_STRENGTH, 2) |
 289                 REG_S(DISP_MISC_CNTL, PALETTE_MEM_RD_MARGIN, 0xb) |
 290                 REG_S(DISP_MISC_CNTL, PALETTE2_MEM_RD_MARGIN, 0xb) |
 291                 REG_S(DISP_MISC_CNTL, RMX_BUF_MEM_RD_MARGIN, 0x5);
 292         state->disp_merge_cntl = REG_S(DISP_MERGE_CNTL, DISP_GRPH_ALPHA, 0xff) |
 293                 REG_S(DISP_MERGE_CNTL, DISP_OV0_ALPHA, 0xff);
 294         state->disp_pwr_man = DISP_PWR_MAN__DISP_PWR_MAN_D3_CRTC_EN |
 295                 DISP_PWR_MAN__DISP2_PWR_MAN_D3_CRTC2_EN |
 296                 REG_S(DISP_PWR_MAN, DISP_PWR_MAN_DPMS, DISP_PWR_MAN_DPMS__OFF) |
 297                 DISP_PWR_MAN__DISP_D3_RST |
 298                 DISP_PWR_MAN__DISP_D3_REG_RST |
 299                 DISP_PWR_MAN__DISP_D3_GRPH_RST |
 300                 DISP_PWR_MAN__DISP_D3_SUBPIC_RST |
 301                 DISP_PWR_MAN__DISP_D3_OV0_RST |
 302                 DISP_PWR_MAN__DISP_D1D2_GRPH_RST |
 303                 DISP_PWR_MAN__DISP_D1D2_SUBPIC_RST |
 304                 DISP_PWR_MAN__DISP_D1D2_OV0_RST |
 305                 DISP_PWR_MAN__DISP_DVO_ENABLE_RST |
 306                 DISP_PWR_MAN__TV_ENABLE_RST;
 307         state->disp2_merge_cntl = 0;
 308         ret = radeon_ms_gpu_address_space_init(dev);
 309         if (ret) {
 310                 return ret;
 311         }
 312
 313         /* initialize bus */
 314         ret = dev_priv->bus_init(dev);
 315         if (ret != 0) {
 316                 return ret;
 317         }
 318         return 0;
 319 }
 320
 321 void radeon_ms_gpu_dpms(struct drm_device *dev)
 322 {
 323         struct drm_radeon_private *dev_priv = dev->dev_private;
 324         struct radeon_state *state = &dev_priv->driver_state;
 325
 326         if (dev_priv->crtc1_dpms == dev_priv->crtc2_dpms) {
 327                 /* both crtc are in same state so use global display pwr */
 328                 state->disp_pwr_man &= ~DISP_PWR_MAN__DISP_PWR_MAN_DPMS__MASK;
 329                 switch(dev_priv->crtc1_dpms) {
 330                 case DPMSModeOn:
 331                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 332                                         DISP_PWR_MAN_DPMS,
 333                                         DISP_PWR_MAN_DPMS__ON);
 334                         break;
 335                 case DPMSModeStandby:
 336                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 337                                         DISP_PWR_MAN_DPMS,
 338                                         DISP_PWR_MAN_DPMS__STANDBY);
 339                         break;
 340                 case DPMSModeSuspend:
 341                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 342                                         DISP_PWR_MAN_DPMS,
 343                                         DISP_PWR_MAN_DPMS__SUSPEND);
 344                         break;
 345                 case DPMSModeOff:
 346                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 347                                         DISP_PWR_MAN_DPMS,
 348                                         DISP_PWR_MAN_DPMS__OFF);
 349                         break;
 350                 default:
 351                         /* error */
 352                         break;
 353                 }
 354                 MMIO_W(DISP_PWR_MAN, state->disp_pwr_man);
 355         } else {
 356                 state->disp_pwr_man &= ~DISP_PWR_MAN__DISP_PWR_MAN_DPMS__MASK;
 357                 state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 358                                 DISP_PWR_MAN_DPMS,
 359                                 DISP_PWR_MAN_DPMS__ON);
 360                 MMIO_W(DISP_PWR_MAN, state->disp_pwr_man);
 361         }
 362 }
 363
 364 void radeon_ms_gpu_flush(struct drm_device *dev)
 365 {
 366         struct drm_radeon_private *dev_priv = dev->dev_private;
 367         uint32_t i;
 368         uint32_t purge2d;
 369         uint32_t purge3d;
 370
 371         switch (dev_priv->family) {
 372         case CHIP_R100:
 373         case CHIP_R200:
 374         case CHIP_RV200:
 375         case CHIP_RV250:
 376         case CHIP_RV280:
 377         case CHIP_RS300:
 378                 purge2d = REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FLUSH, 3) |
 379                         REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FREE, 3);
 380                 purge3d = REG_S(RB3D_DSTCACHE_CTLSTAT, DC_FLUSH, 3) |
 381                         REG_S(RB3D_DSTCACHE_CTLSTAT, DC_FREE, 3);
 382                 MMIO_W(RB2D_DSTCACHE_CTLSTAT, purge2d);
 383                 MMIO_W(RB3D_DSTCACHE_CTLSTAT, purge3d);
 384                 break;
 385         case CHIP_R300:
 386         case CHIP_R350:
 387         case CHIP_R360:
 388         case CHIP_RV350:
 389         case CHIP_RV370:
 390         case CHIP_RV380:
 391         case CHIP_RS400:
 392         case CHIP_RV410:
 393         case CHIP_R420:
 394         case CHIP_R430:
 395         case CHIP_R480:
 396                 purge2d = REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FLUSH, 3) |
 397                         REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FREE, 3);
 398                 purge3d = REG_S(RB3D_DSTCACHE_CTLSTAT_R3, DC_FLUSH, 3) |
 399                         REG_S(RB3D_DSTCACHE_CTLSTAT_R3, DC_FREE, 3);
 400                 MMIO_W(RB2D_DSTCACHE_CTLSTAT, purge2d);
 401                 MMIO_W(RB3D_DSTCACHE_CTLSTAT_R3, purge3d);
 402                 break;
 403         default:
 404                 DRM_INFO("Unknown radeon family, aborting\n");
 405                 return;
 406         }
 407         for (i = 0; i < dev_priv->usec_timeout; i++) {
 408                 if (!(RB2D_DSTCACHE_CTLSTAT__DC_BUSY &
 409                                         MMIO_R(RB2D_DSTCACHE_CTLSTAT))) {
 410                         return;
 411                 }
 412                 DRM_UDELAY(1);
 413         }
 414         DRM_INFO("[radeon_ms] gpu flush timeout\n");
 415 }
 416
 417 void radeon_ms_gpu_restore(struct drm_device *dev, struct radeon_state *state)
 418 {
 419         struct drm_radeon_private *dev_priv = dev->dev_private;
 420         uint32_t wait_until;
 421         uint32_t fbstart;
 422         int ret, ok = 1;
 423
 424         radeon_ms_gpu_reset(dev);
 425         radeon_ms_wait_for_idle(dev);
 426         radeon_ms_gpu_stop(dev);
 427
 428         MMIO_W(AIC_CTRL, state->aic_ctrl);
 429         MMIO_W(MC_FB_LOCATION, state->mc_fb_location);
 430         MMIO_R(MC_FB_LOCATION);
 431         MMIO_W(CONFIG_APER_0_BASE, state->config_aper_0_base);
 432         MMIO_W(CONFIG_APER_1_BASE, state->config_aper_1_base);
 433         MMIO_W(CONFIG_APER_SIZE, state->config_aper_size);
 434         MMIO_W(DISPLAY_BASE_ADDR, state->display_base_addr);
 435         if (dev_priv->bus_restore) {
 436                 dev_priv->bus_restore(dev, state);
 437         }
 438
 439         radeon_ms_gpu_reset(dev);
 440         radeon_ms_gpu_resume(dev);
 441
 442         MMIO_W(BUS_CNTL, state->bus_cntl);
 443         wait_until = WAIT_UNTIL__WAIT_DMA_VIPH0_IDLE |
 444                 WAIT_UNTIL__WAIT_DMA_VIPH1_IDLE |
 445                 WAIT_UNTIL__WAIT_DMA_VIPH2_IDLE |
 446                 WAIT_UNTIL__WAIT_DMA_VIPH3_IDLE |
 447                 WAIT_UNTIL__WAIT_DMA_VID_IDLE |
 448                 WAIT_UNTIL__WAIT_DMA_GUI_IDLE |
 449                 WAIT_UNTIL__WAIT_2D_IDLE |
 450                 WAIT_UNTIL__WAIT_3D_IDLE |
 451                 WAIT_UNTIL__WAIT_2D_IDLECLEAN |
 452                 WAIT_UNTIL__WAIT_3D_IDLECLEAN |
 453                 WAIT_UNTIL__WAIT_HOST_IDLECLEAN;
 454         switch (dev_priv->family) {
 455         case CHIP_R100:
 456         case CHIP_R200:
 457         case CHIP_RV200:
 458         case CHIP_RV250:
 459         case CHIP_RV280:
 460         case CHIP_RS300:
 461                 break;
 462         case CHIP_R300:
 463         case CHIP_R350:
 464         case CHIP_R360:
 465         case CHIP_RV350:
 466         case CHIP_RV370:
 467         case CHIP_RV380:
 468         case CHIP_RS400:
 469         case CHIP_RV410:
 470         case CHIP_R420:
 471         case CHIP_R430:
 472         case CHIP_R480:
 473                 wait_until |= WAIT_UNTIL__WAIT_VAP_IDLE;
 474                 break;
 475         }
 476         MMIO_W(WAIT_UNTIL, wait_until);
 477         MMIO_W(DISP_MISC_CNTL, state->disp_misc_cntl);
 478         MMIO_W(DISP_PWR_MAN, state->disp_pwr_man);
 479         MMIO_W(DISP_MERGE_CNTL, state->disp_merge_cntl);
 480         MMIO_W(DISP_OUTPUT_CNTL, state->disp_output_cntl);
 481         MMIO_W(DISP2_MERGE_CNTL, state->disp2_merge_cntl);
 482
 483         /* Setup engine location. This shouldn't be necessary since we
 484          * set them appropriately before any accel ops, but let's avoid
 485          * random bogus DMA in case we inadvertently trigger the engine
 486          * in the wrong place (happened).
 487          */
 488         ret = radeon_ms_wait_for_fifo(dev, 2);
 489         if (ret) {
 490                 ok = 0;
 491                 DRM_INFO("[radeon_ms] no fifo for setting up dst & src gui\n");
 492                 DRM_INFO("[radeon_ms] proceed anyway\n");
 493         }
 494         fbstart = (MC_FB_LOCATION__MC_FB_START__MASK &
 495                         MMIO_R(MC_FB_LOCATION)) << 16;
 496         MMIO_W(DST_PITCH_OFFSET,
 497                 REG_S(DST_PITCH_OFFSET, DST_OFFSET, fbstart >> 10));
 498         MMIO_W(SRC_PITCH_OFFSET,
 499                 REG_S(SRC_PITCH_OFFSET, SRC_OFFSET, fbstart >> 10));
 500
 501         ret = radeon_ms_wait_for_fifo(dev, 1);
 502         if (ret) {
 503                 ok = 0;
 504                 DRM_INFO("[radeon_ms] no fifo for setting up dp data type\n");
 505                 DRM_INFO("[radeon_ms] proceed anyway\n");
 506         }
 507 #ifdef __BIG_ENDIAN
 508         MMIO_W(DP_DATATYPE, DP_DATATYPE__DP_BYTE_PIX_ORDER);
 509 #else
 510         MMIO_W(DP_DATATYPE, 0);
 511 #endif
 512
 513         ret = radeon_ms_wait_for_fifo(dev, 1);
 514         if (ret) {
 515                 ok = 0;
 516                 DRM_INFO("[radeon_ms] no fifo for setting up surface cntl\n");
 517                 DRM_INFO("[radeon_ms] proceed anyway\n");
 518         }
 519         MMIO_W(SURFACE_CNTL, SURFACE_CNTL__SURF_TRANSLATION_DIS);
 520
 521         ret = radeon_ms_wait_for_fifo(dev, 2);
 522         if (ret) {
 523                 ok = 0;
 524                 DRM_INFO("[radeon_ms] no fifo for setting scissor\n");
 525                 DRM_INFO("[radeon_ms] proceed anyway\n");
 526         }
 527         MMIO_W(DEFAULT_SC_BOTTOM_RIGHT, 0x1fff1fff);
 528         MMIO_W(DEFAULT2_SC_BOTTOM_RIGHT, 0x1fff1fff);
 529
 530         ret = radeon_ms_wait_for_fifo(dev, 1);
 531         if (ret) {
 532                 ok = 0;
 533                 DRM_INFO("[radeon_ms] no fifo for setting up gui cntl\n");
 534                 DRM_INFO("[radeon_ms] proceed anyway\n");
 535         }
 536         MMIO_W(DP_GUI_MASTER_CNTL, 0);
 537
 538         ret = radeon_ms_wait_for_fifo(dev, 5);
 539         if (ret) {
 540                 ok = 0;
 541                 DRM_INFO("[radeon_ms] no fifo for setting up clear color\n");
 542                 DRM_INFO("[radeon_ms] proceed anyway\n");
 543         }
 544         MMIO_W(DP_BRUSH_BKGD_CLR, 0x00000000);
 545         MMIO_W(DP_BRUSH_FRGD_CLR, 0xffffffff);
 546         MMIO_W(DP_SRC_BKGD_CLR, 0x00000000);
 547         MMIO_W(DP_SRC_FRGD_CLR, 0xffffffff);
 548         MMIO_W(DP_WRITE_MSK, 0xffffffff);
 549
 550         if (!ok) {
 551                 DRM_INFO("[radeon_ms] engine restore not enough fifo\n");
 552         }
 553 }
 554
 555 void radeon_ms_gpu_save(struct drm_device *dev, struct radeon_state *state)
 556 {
 557         struct drm_radeon_private *dev_priv = dev->dev_private;
 558
 559         state->aic_ctrl = MMIO_R(AIC_CTRL);
 560         state->bus_cntl = MMIO_R(BUS_CNTL);
 561         state->mc_fb_location = MMIO_R(MC_FB_LOCATION);
 562         state->display_base_addr = MMIO_R(DISPLAY_BASE_ADDR);
 563         state->config_aper_0_base = MMIO_R(CONFIG_APER_0_BASE);
 564         state->config_aper_1_base = MMIO_R(CONFIG_APER_1_BASE);
 565         state->config_aper_size = MMIO_R(CONFIG_APER_SIZE);
 566         state->disp_misc_cntl = MMIO_R(DISP_MISC_CNTL);
 567         state->disp_pwr_man = MMIO_R(DISP_PWR_MAN);
 568         state->disp_merge_cntl = MMIO_R(DISP_MERGE_CNTL);
 569         state->disp_output_cntl = MMIO_R(DISP_OUTPUT_CNTL);
 570         state->disp2_merge_cntl = MMIO_R(DISP2_MERGE_CNTL);
 571         if (dev_priv->bus_save) {
 572                 dev_priv->bus_save(dev, state);
 573         }
 574 }
 575
 576 int radeon_ms_wait_for_idle(struct drm_device *dev)
 577 {
 578         struct drm_radeon_private *dev_priv = dev->dev_private;
 579         int i, j, ret;
 580
 581         for (i = 0; i < 2; i++) {
 582                 ret = radeon_ms_wait_for_fifo(dev, 64);
 583                 if (ret) {
 584                         DRM_INFO("[radeon_ms] fifo not empty\n");
 585                 }
 586                 for (j = 0; j < dev_priv->usec_timeout; j++) {
 587                         if (!(RBBM_STATUS__GUI_ACTIVE & MMIO_R(RBBM_STATUS))) {
 588                                 radeon_ms_gpu_flush(dev);
 589                                 return 0;
 590                         }
 591                         DRM_UDELAY(1);
 592                 }
 593                 DRM_INFO("[radeon_ms] idle timed out:  status=0x%08x\n",
 594                                 MMIO_R(RBBM_STATUS));
 595                 radeon_ms_gpu_reset(dev);
 596                 radeon_ms_gpu_resume(dev);
 597         }
 598         return -EBUSY;
 599 }