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         cache_mode = MMIO_R(RB2D_DSTCACHE_MODE);
 132         MMIO_W(RB2D_DSTCACHE_MODE,
 133                         cache_mode | RB2D_DSTCACHE_MODE__DC_DISABLE_IGNORE_PE);
 134
 135         MMIO_W(HOST_PATH_CNTL, host_path_cntl | HOST_PATH_CNTL__HDP_SOFT_RESET);
 136         MMIO_R(HOST_PATH_CNTL);
 137         MMIO_W(HOST_PATH_CNTL, host_path_cntl);
 138         MMIO_R(HOST_PATH_CNTL);
 139
 140         MMIO_W(CLOCK_CNTL_INDEX, clock_cntl_index);
 141         pll_index_errata(dev_priv);
 142         PPLL_W(MCLK_CNTL, mclk_cntl);
 143 }
 144
 145 static void radeon_ms_gpu_resume(struct drm_device *dev)
 146 {
 147         struct drm_radeon_private *dev_priv = dev->dev_private;
 148         uint32_t a;
 149         uint32_t i;
 150
 151         /* make sure we have sane offset before restoring crtc */
 152         a = (MMIO_R(MC_FB_LOCATION) & MC_FB_LOCATION__MC_FB_START__MASK) << 16;
 153         MMIO_W(DISPLAY_BASE_ADDR, a);
 154         MMIO_W(CRTC2_DISPLAY_BASE_ADDR, a);
 155         MMIO_W(CRTC_OFFSET, 0);
 156         MMIO_W(CUR_OFFSET, 0);
 157         MMIO_W(CRTC_OFFSET_CNTL, CRTC_OFFSET_CNTL__CRTC_OFFSET_FLIP_CNTL);
 158         MMIO_W(CRTC2_OFFSET, 0);
 159         MMIO_W(CUR2_OFFSET, 0);
 160         MMIO_W(CRTC2_OFFSET_CNTL, CRTC2_OFFSET_CNTL__CRTC2_OFFSET_FLIP_CNTL);
 161         for (i = 0; i < dev_priv->usec_timeout; i++) {
 162                 if (!(CRTC_OFFSET__CRTC_GUI_TRIG_OFFSET &
 163                       MMIO_R(CRTC_OFFSET))) {
 164                         break;
 165                 }
 166                 DRM_UDELAY(1);
 167         }
 168         if (i >= dev_priv->usec_timeout) {
 169                 DRM_ERROR("[radeon_ms] timeout waiting for crtc...\n");
 170         }
 171         for (i = 0; i < dev_priv->usec_timeout; i++) {
 172                 if (!(CRTC2_OFFSET__CRTC2_GUI_TRIG_OFFSET &
 173                       MMIO_R(CRTC2_OFFSET))) {
 174                         break;
 175                 }
 176                 DRM_UDELAY(1);
 177         }
 178         if (i >= dev_priv->usec_timeout) {
 179                 DRM_ERROR("[radeon_ms] timeout waiting for crtc...\n");
 180         }
 181         DRM_UDELAY(10000);
 182 }
 183
 184 static void radeon_ms_gpu_stop(struct drm_device *dev)
 185 {
 186         struct drm_radeon_private *dev_priv = dev->dev_private;
 187         uint32_t ov0_scale_cntl, crtc_ext_cntl, crtc_gen_cntl;
 188         uint32_t crtc2_gen_cntl, i;
 189
 190         radeon_ms_wait_for_idle(dev);
 191         /* Capture MC_STATUS in case things go wrong ... */
 192         ov0_scale_cntl = dev_priv->ov0_scale_cntl = MMIO_R(OV0_SCALE_CNTL);
 193         crtc_ext_cntl = dev_priv->crtc_ext_cntl = MMIO_R(CRTC_EXT_CNTL);
 194         crtc_gen_cntl = dev_priv->crtc_gen_cntl = MMIO_R(CRTC_GEN_CNTL);
 195         crtc2_gen_cntl = dev_priv->crtc2_gen_cntl = MMIO_R(CRTC2_GEN_CNTL);
 196         ov0_scale_cntl &= ~OV0_SCALE_CNTL__OV0_OVERLAY_EN__MASK;
 197         crtc_ext_cntl |= CRTC_EXT_CNTL__CRTC_DISPLAY_DIS;
 198         crtc_gen_cntl &= ~CRTC_GEN_CNTL__CRTC_CUR_EN;
 199         crtc_gen_cntl &= ~CRTC_GEN_CNTL__CRTC_ICON_EN;
 200         crtc_gen_cntl |= CRTC_GEN_CNTL__CRTC_EXT_DISP_EN;
 201         crtc_gen_cntl |= CRTC_GEN_CNTL__CRTC_DISP_REQ_EN_B;
 202         crtc2_gen_cntl &= ~CRTC2_GEN_CNTL__CRTC2_CUR_EN;
 203         crtc2_gen_cntl &= ~CRTC2_GEN_CNTL__CRTC2_ICON_EN;
 204         crtc2_gen_cntl |= CRTC2_GEN_CNTL__CRTC2_DISP_REQ_EN_B;
 205         MMIO_W(OV0_SCALE_CNTL, ov0_scale_cntl);
 206         MMIO_W(CRTC_EXT_CNTL, crtc_ext_cntl);
 207         MMIO_W(CRTC_GEN_CNTL, crtc_gen_cntl);
 208         MMIO_W(CRTC2_GEN_CNTL, crtc2_gen_cntl);
 209         DRM_UDELAY(10000);
 210         switch (dev_priv->family) {
 211         case CHIP_R100:
 212         case CHIP_R200:
 213         case CHIP_RV200:
 214         case CHIP_RV250:
 215         case CHIP_RV280:
 216         case CHIP_RS300:
 217                 for (i = 0; i < dev_priv->usec_timeout; i++) {
 218                         if ((MC_STATUS__MC_IDLE & MMIO_R(MC_STATUS))) {
 219                                 DRM_INFO("[radeon_ms] gpu stoped in %d usecs\n",
 220                                          i);
 221                                 return;
 222                         }
 223                         DRM_UDELAY(1);
 224                 }
 225                 break;
 226         case CHIP_R300:
 227         case CHIP_R350:
 228         case CHIP_R360:
 229         case CHIP_RV350:
 230         case CHIP_RV370:
 231         case CHIP_RV380:
 232         case CHIP_RS400:
 233         case CHIP_RV410:
 234         case CHIP_R420:
 235         case CHIP_R430:
 236         case CHIP_R480:
 237                 for (i = 0; i < dev_priv->usec_timeout; i++) {
 238                         if ((MC_STATUS__MC_IDLE_R3 & MMIO_R(MC_STATUS))) {
 239                                 DRM_INFO("[radeon_ms] gpu stoped in %d usecs\n",
 240                                          i);
 241                                 return;
 242                         }
 243                         DRM_UDELAY(1);
 244                 }
 245                 break;
 246         default:
 247                 DRM_ERROR("Unknown radeon family, aborting\n");
 248                 return;
 249         }
 250         DRM_ERROR("[radeon_ms] failed to stop gpu...will proceed anyway\n");
 251         DRM_UDELAY(20000);
 252 }
 253
 254 static int radeon_ms_wait_for_fifo(struct drm_device *dev, int num_fifo)
 255 {
 256         struct drm_radeon_private *dev_priv = dev->dev_private;
 257         int i;
 258
 259         for (i = 0; i < dev_priv->usec_timeout; i++) {
 260                 int t;
 261                 t = RBBM_STATUS__CMDFIFO_AVAIL__MASK & MMIO_R(RBBM_STATUS);
 262                 t = t >> RBBM_STATUS__CMDFIFO_AVAIL__SHIFT;
 263                 if (t >= num_fifo)
 264                         return 0;
 265                 DRM_UDELAY(1);
 266         }
 267         DRM_ERROR("[radeon_ms] failed to wait for fifo\n");
 268         return -EBUSY;
 269 }
 270
 271 int radeon_ms_gpu_initialize(struct drm_device *dev)
 272 {
 273         struct drm_radeon_private *dev_priv = dev->dev_private;
 274         struct radeon_state *state = &dev_priv->driver_state;
 275         int ret;
 276
 277         state->disp_misc_cntl = DISP_MISC_CNTL__SYNC_PAD_FLOP_EN |
 278                 REG_S(DISP_MISC_CNTL, SYNC_STRENGTH, 2) |
 279                 REG_S(DISP_MISC_CNTL, PALETTE_MEM_RD_MARGIN, 0xb) |
 280                 REG_S(DISP_MISC_CNTL, PALETTE2_MEM_RD_MARGIN, 0xb) |
 281                 REG_S(DISP_MISC_CNTL, RMX_BUF_MEM_RD_MARGIN, 0x5);
 282         state->disp_merge_cntl = REG_S(DISP_MERGE_CNTL, DISP_GRPH_ALPHA, 0xff) |
 283                 REG_S(DISP_MERGE_CNTL, DISP_OV0_ALPHA, 0xff);
 284         state->disp_pwr_man = DISP_PWR_MAN__DISP_PWR_MAN_D3_CRTC_EN |
 285                 DISP_PWR_MAN__DISP2_PWR_MAN_D3_CRTC2_EN |
 286                 REG_S(DISP_PWR_MAN, DISP_PWR_MAN_DPMS, DISP_PWR_MAN_DPMS__OFF) |
 287                 DISP_PWR_MAN__DISP_D3_RST |
 288                 DISP_PWR_MAN__DISP_D3_REG_RST |
 289                 DISP_PWR_MAN__DISP_D3_GRPH_RST |
 290                 DISP_PWR_MAN__DISP_D3_SUBPIC_RST |
 291                 DISP_PWR_MAN__DISP_D3_OV0_RST |
 292                 DISP_PWR_MAN__DISP_D1D2_GRPH_RST |
 293                 DISP_PWR_MAN__DISP_D1D2_SUBPIC_RST |
 294                 DISP_PWR_MAN__DISP_D1D2_OV0_RST |
 295                 DISP_PWR_MAN__DISP_DVO_ENABLE_RST |
 296                 DISP_PWR_MAN__TV_ENABLE_RST;
 297         state->disp2_merge_cntl = 0;
 298         ret = radeon_ms_gpu_address_space_init(dev);
 299         if (ret) {
 300                 return ret;
 301         }
 302
 303         /* initialize bus */
 304         ret = dev_priv->bus_init(dev);
 305         if (ret != 0) {
 306                 return ret;
 307         }
 308         return 0;
 309 }
 310
 311 void radeon_ms_gpu_dpms(struct drm_device *dev)
 312 {
 313         struct drm_radeon_private *dev_priv = dev->dev_private;
 314         struct radeon_state *state = &dev_priv->driver_state;
 315
 316         if (dev_priv->crtc1_dpms == dev_priv->crtc2_dpms) {
 317                 /* both crtc are in same state so use global display pwr */
 318                 state->disp_pwr_man &= ~DISP_PWR_MAN__DISP_PWR_MAN_DPMS__MASK;
 319                 switch(dev_priv->crtc1_dpms) {
 320                 case DPMSModeOn:
 321                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 322                                         DISP_PWR_MAN_DPMS,
 323                                         DISP_PWR_MAN_DPMS__ON);
 324                         break;
 325                 case DPMSModeStandby:
 326                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 327                                         DISP_PWR_MAN_DPMS,
 328                                         DISP_PWR_MAN_DPMS__STANDBY);
 329                         break;
 330                 case DPMSModeSuspend:
 331                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 332                                         DISP_PWR_MAN_DPMS,
 333                                         DISP_PWR_MAN_DPMS__SUSPEND);
 334                         break;
 335                 case DPMSModeOff:
 336                         state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 337                                         DISP_PWR_MAN_DPMS,
 338                                         DISP_PWR_MAN_DPMS__OFF);
 339                         break;
 340                 default:
 341                         /* error */
 342                         break;
 343                 }
 344                 MMIO_W(DISP_PWR_MAN, state->disp_pwr_man);
 345         } else {
 346                 state->disp_pwr_man &= ~DISP_PWR_MAN__DISP_PWR_MAN_DPMS__MASK;
 347                 state->disp_pwr_man |= REG_S(DISP_PWR_MAN,
 348                                 DISP_PWR_MAN_DPMS,
 349                                 DISP_PWR_MAN_DPMS__ON);
 350                 MMIO_W(DISP_PWR_MAN, state->disp_pwr_man);
 351         }
 352 }
 353
 354 void radeon_ms_gpu_flush(struct drm_device *dev)
 355 {
 356         struct drm_radeon_private *dev_priv = dev->dev_private;
 357         uint32_t i;
 358         uint32_t purge2d;
 359         uint32_t purge3d;
 360
 361         switch (dev_priv->family) {
 362         case CHIP_R100:
 363         case CHIP_R200:
 364         case CHIP_RV200:
 365         case CHIP_RV250:
 366         case CHIP_RV280:
 367         case CHIP_RS300:
 368                 purge2d = REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FLUSH, 3) |
 369                         REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FREE, 3);
 370                 purge3d = REG_S(RB3D_DSTCACHE_CTLSTAT, DC_FLUSH, 3) |
 371                         REG_S(RB3D_DSTCACHE_CTLSTAT, DC_FREE, 3);
 372                 MMIO_W(RB2D_DSTCACHE_CTLSTAT, purge2d);
 373                 MMIO_W(RB3D_DSTCACHE_CTLSTAT, purge3d);
 374                 break;
 375         case CHIP_R300:
 376         case CHIP_R350:
 377         case CHIP_R360:
 378         case CHIP_RV350:
 379         case CHIP_RV370:
 380         case CHIP_RV380:
 381         case CHIP_RS400:
 382         case CHIP_RV410:
 383         case CHIP_R420:
 384         case CHIP_R430:
 385         case CHIP_R480:
 386                 purge2d = REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FLUSH, 3) |
 387                         REG_S(RB2D_DSTCACHE_CTLSTAT, DC_FREE, 3);
 388                 purge3d = REG_S(RB3D_DSTCACHE_CTLSTAT_R3, DC_FLUSH, 3) |
 389                         REG_S(RB3D_DSTCACHE_CTLSTAT_R3, DC_FREE, 3);
 390                 MMIO_W(RB2D_DSTCACHE_CTLSTAT, purge2d);
 391                 MMIO_W(RB3D_DSTCACHE_CTLSTAT_R3, purge3d);
 392                 break;
 393         default:
 394                 DRM_ERROR("Unknown radeon family, aborting\n");
 395                 return;
 396         }
 397         for (i = 0; i < dev_priv->usec_timeout; i++) {
 398                 if (!(RB2D_DSTCACHE_CTLSTAT__DC_BUSY &
 399                                         MMIO_R(RB2D_DSTCACHE_CTLSTAT))) {
 400                         return;
 401                 }
 402                 DRM_UDELAY(1);
 403         }
 404         DRM_ERROR("[radeon_ms] gpu flush timeout\n");
 405 }
 406
 407 void radeon_ms_gpu_restore(struct drm_device *dev, struct radeon_state *state)
 408 {
 409         struct drm_radeon_private *dev_priv = dev->dev_private;
 410         uint32_t wait_until;
 411         uint32_t fbstart;
 412         int ret, ok = 1;
 413
 414         radeon_ms_gpu_reset(dev);
 415         radeon_ms_wait_for_idle(dev);
 416         radeon_ms_gpu_stop(dev);
 417
 418         MMIO_W(AIC_CTRL, state->aic_ctrl);
 419         MMIO_W(MC_FB_LOCATION, state->mc_fb_location);
 420         MMIO_R(MC_FB_LOCATION);
 421         MMIO_W(CONFIG_APER_0_BASE, state->config_aper_0_base);
 422         MMIO_W(CONFIG_APER_1_BASE, state->config_aper_1_base);
 423         MMIO_W(CONFIG_APER_SIZE, state->config_aper_size);
 424         MMIO_W(DISPLAY_BASE_ADDR, state->display_base_addr);
 425         if (dev_priv->bus_restore) {
 426                 dev_priv->bus_restore(dev, state);
 427         }
 428
 429         radeon_ms_gpu_reset(dev);
 430         radeon_ms_gpu_resume(dev);
 431
 432         MMIO_W(BUS_CNTL, state->bus_cntl);
 433         wait_until = WAIT_UNTIL__WAIT_DMA_VIPH0_IDLE |
 434                 WAIT_UNTIL__WAIT_DMA_VIPH1_IDLE |
 435                 WAIT_UNTIL__WAIT_DMA_VIPH2_IDLE |
 436                 WAIT_UNTIL__WAIT_DMA_VIPH3_IDLE |
 437                 WAIT_UNTIL__WAIT_DMA_VID_IDLE |
 438                 WAIT_UNTIL__WAIT_DMA_GUI_IDLE |
 439                 WAIT_UNTIL__WAIT_2D_IDLE |
 440                 WAIT_UNTIL__WAIT_3D_IDLE |
 441                 WAIT_UNTIL__WAIT_2D_IDLECLEAN |
 442                 WAIT_UNTIL__WAIT_3D_IDLECLEAN |
 443                 WAIT_UNTIL__WAIT_HOST_IDLECLEAN;
 444         switch (dev_priv->family) {
 445         case CHIP_R100:
 446         case CHIP_R200:
 447         case CHIP_RV200:
 448         case CHIP_RV250:
 449         case CHIP_RV280:
 450         case CHIP_RS300:
 451                 break;
 452         case CHIP_R300:
 453         case CHIP_R350:
 454         case CHIP_R360:
 455         case CHIP_RV350:
 456         case CHIP_RV370:
 457         case CHIP_RV380:
 458         case CHIP_RS400:
 459         case CHIP_RV410:
 460         case CHIP_R420:
 461         case CHIP_R430:
 462         case CHIP_R480:
 463                 wait_until |= WAIT_UNTIL__WAIT_VAP_IDLE;
 464                 break;
 465         }
 466         MMIO_W(WAIT_UNTIL, wait_until);
 467         MMIO_W(DISP_MISC_CNTL, state->disp_misc_cntl);
 468         MMIO_W(DISP_PWR_MAN, state->disp_pwr_man);
 469         MMIO_W(DISP_MERGE_CNTL, state->disp_merge_cntl);
 470         MMIO_W(DISP_OUTPUT_CNTL, state->disp_output_cntl);
 471         MMIO_W(DISP2_MERGE_CNTL, state->disp2_merge_cntl);
 472
 473         /* Setup engine location. This shouldn't be necessary since we
 474          * set them appropriately before any accel ops, but let's avoid
 475          * random bogus DMA in case we inadvertently trigger the engine
 476          * in the wrong place (happened).
 477          */
 478         ret = radeon_ms_wait_for_fifo(dev, 2);
 479         if (ret) {
 480                 ok = 0;
 481                 DRM_ERROR("[radeon_ms] no fifo for setting up dst & src gui\n");
 482                 DRM_ERROR("[radeon_ms] proceed anyway\n");
 483         }
 484         fbstart = (MC_FB_LOCATION__MC_FB_START__MASK &
 485                         MMIO_R(MC_FB_LOCATION)) << 16;
 486         MMIO_W(DST_PITCH_OFFSET,
 487                 REG_S(DST_PITCH_OFFSET, DST_OFFSET, fbstart >> 10));
 488         MMIO_W(SRC_PITCH_OFFSET,
 489                 REG_S(SRC_PITCH_OFFSET, SRC_OFFSET, fbstart >> 10));
 490
 491         ret = radeon_ms_wait_for_fifo(dev, 1);
 492         if (ret) {
 493                 ok = 0;
 494                 DRM_ERROR("[radeon_ms] no fifo for setting up dp data type\n");
 495                 DRM_ERROR("[radeon_ms] proceed anyway\n");
 496         }
 497 #ifdef __BIG_ENDIAN
 498         MMIO_W(DP_DATATYPE, DP_DATATYPE__DP_BYTE_PIX_ORDER);
 499 #else
 500         MMIO_W(DP_DATATYPE, 0);
 501 #endif
 502
 503         ret = radeon_ms_wait_for_fifo(dev, 1);
 504         if (ret) {
 505                 ok = 0;
 506                 DRM_ERROR("[radeon_ms] no fifo for setting up surface cntl\n");
 507                 DRM_ERROR("[radeon_ms] proceed anyway\n");
 508         }
 509         MMIO_W(SURFACE_CNTL, SURFACE_CNTL__SURF_TRANSLATION_DIS);
 510
 511         ret = radeon_ms_wait_for_fifo(dev, 2);
 512         if (ret) {
 513                 ok = 0;
 514                 DRM_ERROR("[radeon_ms] no fifo for setting scissor\n");
 515                 DRM_ERROR("[radeon_ms] proceed anyway\n");
 516         }
 517         MMIO_W(DEFAULT_SC_BOTTOM_RIGHT, 0x1fff1fff);
 518         MMIO_W(DEFAULT2_SC_BOTTOM_RIGHT, 0x1fff1fff);
 519
 520         ret = radeon_ms_wait_for_fifo(dev, 1);
 521         if (ret) {
 522                 ok = 0;
 523                 DRM_ERROR("[radeon_ms] no fifo for setting up gui cntl\n");
 524                 DRM_ERROR("[radeon_ms] proceed anyway\n");
 525         }
 526         MMIO_W(DP_GUI_MASTER_CNTL, 0);
 527
 528         ret = radeon_ms_wait_for_fifo(dev, 5);
 529         if (ret) {
 530                 ok = 0;
 531                 DRM_ERROR("[radeon_ms] no fifo for setting up clear color\n");
 532                 DRM_ERROR("[radeon_ms] proceed anyway\n");
 533         }
 534         MMIO_W(DP_BRUSH_BKGD_CLR, 0x00000000);
 535         MMIO_W(DP_BRUSH_FRGD_CLR, 0xffffffff);
 536         MMIO_W(DP_SRC_BKGD_CLR, 0x00000000);
 537         MMIO_W(DP_SRC_FRGD_CLR, 0xffffffff);
 538         MMIO_W(DP_WRITE_MSK, 0xffffffff);
 539
 540         if (!ok) {
 541                 DRM_ERROR("[radeon_ms] engine restore not enough fifo\n");
 542         }
 543 }
 544
 545 void radeon_ms_gpu_save(struct drm_device *dev, struct radeon_state *state)
 546 {
 547         struct drm_radeon_private *dev_priv = dev->dev_private;
 548
 549         state->aic_ctrl = MMIO_R(AIC_CTRL);
 550         state->bus_cntl = MMIO_R(BUS_CNTL);
 551         state->mc_fb_location = MMIO_R(MC_FB_LOCATION);
 552         state->display_base_addr = MMIO_R(DISPLAY_BASE_ADDR);
 553         state->config_aper_0_base = MMIO_R(CONFIG_APER_0_BASE);
 554         state->config_aper_1_base = MMIO_R(CONFIG_APER_1_BASE);
 555         state->config_aper_size = MMIO_R(CONFIG_APER_SIZE);
 556         state->disp_misc_cntl = MMIO_R(DISP_MISC_CNTL);
 557         state->disp_pwr_man = MMIO_R(DISP_PWR_MAN);
 558         state->disp_merge_cntl = MMIO_R(DISP_MERGE_CNTL);
 559         state->disp_output_cntl = MMIO_R(DISP_OUTPUT_CNTL);
 560         state->disp2_merge_cntl = MMIO_R(DISP2_MERGE_CNTL);
 561         if (dev_priv->bus_save) {
 562                 dev_priv->bus_save(dev, state);
 563         }
 564 }
 565
 566 int radeon_ms_wait_for_idle(struct drm_device *dev)
 567 {
 568         struct drm_radeon_private *dev_priv = dev->dev_private;
 569         int i, j, ret;
 570
 571         for (i = 0; i < 2; i++) {
 572                 ret = radeon_ms_wait_for_fifo(dev, 64);
 573                 if (ret) {
 574                         DRM_ERROR("[radeon_ms] fifo not empty\n");
 575                 }
 576                 for (j = 0; j < dev_priv->usec_timeout; j++) {
 577                         if (!(RBBM_STATUS__GUI_ACTIVE & MMIO_R(RBBM_STATUS))) {
 578                                 radeon_ms_gpu_flush(dev);
 579                                 return 0;
 580                         }
 581                         DRM_UDELAY(1);
 582                 }
 583                 DRM_ERROR("[radeon_ms] idle timed out:  status=0x%08x\n",
 584                                 MMIO_R(RBBM_STATUS));
 585                 radeon_ms_gpu_stop(dev);
 586                 radeon_ms_gpu_reset(dev);
 587         }
 588         return -EBUSY;
 589 }