Pileus Git - ~andy/linux/blob - drivers/gpu/drm/radeon/rv770.c

   1 /*
   2  * Copyright 2008 Advanced Micro Devices, Inc.
   3  * Copyright 2008 Red Hat Inc.
   4  * Copyright 2009 Jerome Glisse.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors: Dave Airlie
  25  *          Alex Deucher
  26  *          Jerome Glisse
  27  */
  28 #include <linux/firmware.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/slab.h>
  31 #include <drm/drmP.h>
  32 #include "radeon.h"
  33 #include "radeon_asic.h"
  34 #include <drm/radeon_drm.h>
  35 #include "rv770d.h"
  36 #include "atom.h"
  37 #include "avivod.h"
  38
  39 #define R700_PFP_UCODE_SIZE 848
  40 #define R700_PM4_UCODE_SIZE 1360
  41
  42 static void rv770_gpu_init(struct radeon_device *rdev);
  43 void rv770_fini(struct radeon_device *rdev);
  44 static void rv770_pcie_gen2_enable(struct radeon_device *rdev);
  45 int evergreen_set_uvd_clocks(struct radeon_device *rdev, u32 vclk, u32 dclk);
  46
  47 int rv770_set_uvd_clocks(struct radeon_device *rdev, u32 vclk, u32 dclk)
  48 {
  49         unsigned fb_div = 0, vclk_div = 0, dclk_div = 0;
  50         int r;
  51
  52         /* RV740 uses evergreen uvd clk programming */
  53         if (rdev->family == CHIP_RV740)
  54                 return evergreen_set_uvd_clocks(rdev, vclk, dclk);
  55
  56         /* bypass vclk and dclk with bclk */
  57         WREG32_P(CG_UPLL_FUNC_CNTL_2,
  58                  VCLK_SRC_SEL(1) | DCLK_SRC_SEL(1),
  59                  ~(VCLK_SRC_SEL_MASK | DCLK_SRC_SEL_MASK));
  60
  61         if (!vclk || !dclk) {
  62                 /* keep the Bypass mode, put PLL to sleep */
  63                 WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_SLEEP_MASK, ~UPLL_SLEEP_MASK);
  64                 return 0;
  65         }
  66
  67         r = radeon_uvd_calc_upll_dividers(rdev, vclk, dclk, 50000, 160000,
  68                                           43663, 0x03FFFFFE, 1, 30, ~0,
  69                                           &fb_div, &vclk_div, &dclk_div);
  70         if (r)
  71                 return r;
  72
  73         fb_div |= 1;
  74         vclk_div -= 1;
  75         dclk_div -= 1;
  76
  77         /* set UPLL_FB_DIV to 0x50000 */
  78         WREG32_P(CG_UPLL_FUNC_CNTL_3, UPLL_FB_DIV(0x50000), ~UPLL_FB_DIV_MASK);
  79
  80         /* deassert UPLL_RESET and UPLL_SLEEP */
  81         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~(UPLL_RESET_MASK | UPLL_SLEEP_MASK));
  82
  83         /* assert BYPASS EN and FB_DIV[0] <- ??? why? */
  84         WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_BYPASS_EN_MASK, ~UPLL_BYPASS_EN_MASK);
  85         WREG32_P(CG_UPLL_FUNC_CNTL_3, UPLL_FB_DIV(1), ~UPLL_FB_DIV(1));
  86
  87         r = radeon_uvd_send_upll_ctlreq(rdev, CG_UPLL_FUNC_CNTL);
  88         if (r)
  89                 return r;
  90
  91         /* assert PLL_RESET */
  92         WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_RESET_MASK, ~UPLL_RESET_MASK);
  93
  94         /* set the required FB_DIV, REF_DIV, Post divder values */
  95         WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_REF_DIV(1), ~UPLL_REF_DIV_MASK);
  96         WREG32_P(CG_UPLL_FUNC_CNTL_2,
  97                  UPLL_SW_HILEN(vclk_div >> 1) |
  98                  UPLL_SW_LOLEN((vclk_div >> 1) + (vclk_div & 1)) |
  99                  UPLL_SW_HILEN2(dclk_div >> 1) |
 100                  UPLL_SW_LOLEN2((dclk_div >> 1) + (dclk_div & 1)),
 101                  ~UPLL_SW_MASK);
 102
 103         WREG32_P(CG_UPLL_FUNC_CNTL_3, UPLL_FB_DIV(fb_div),
 104                  ~UPLL_FB_DIV_MASK);
 105
 106         /* give the PLL some time to settle */
 107         mdelay(15);
 108
 109         /* deassert PLL_RESET */
 110         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_RESET_MASK);
 111
 112         mdelay(15);
 113
 114         /* deassert BYPASS EN and FB_DIV[0] <- ??? why? */
 115         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_BYPASS_EN_MASK);
 116         WREG32_P(CG_UPLL_FUNC_CNTL_3, 0, ~UPLL_FB_DIV(1));
 117
 118         r = radeon_uvd_send_upll_ctlreq(rdev, CG_UPLL_FUNC_CNTL);
 119         if (r)
 120                 return r;
 121
 122         /* switch VCLK and DCLK selection */
 123         WREG32_P(CG_UPLL_FUNC_CNTL_2,
 124                  VCLK_SRC_SEL(2) | DCLK_SRC_SEL(2),
 125                  ~(VCLK_SRC_SEL_MASK | DCLK_SRC_SEL_MASK));
 126
 127         mdelay(100);
 128
 129         return 0;
 130 }
 131
 132 static const u32 r7xx_golden_registers[] =
 133 {
 134         0x8d00, 0xffffffff, 0x0e0e0074,
 135         0x8d04, 0xffffffff, 0x013a2b34,
 136         0x9508, 0xffffffff, 0x00000002,
 137         0x8b20, 0xffffffff, 0,
 138         0x88c4, 0xffffffff, 0x000000c2,
 139         0x28350, 0xffffffff, 0,
 140         0x9058, 0xffffffff, 0x0fffc40f,
 141         0x240c, 0xffffffff, 0x00000380,
 142         0x733c, 0xffffffff, 0x00000002,
 143         0x2650, 0x00040000, 0,
 144         0x20bc, 0x00040000, 0,
 145         0x7300, 0xffffffff, 0x001000f0
 146 };
 147
 148 static const u32 r7xx_golden_dyn_gpr_registers[] =
 149 {
 150         0x8db0, 0xffffffff, 0x98989898,
 151         0x8db4, 0xffffffff, 0x98989898,
 152         0x8db8, 0xffffffff, 0x98989898,
 153         0x8dbc, 0xffffffff, 0x98989898,
 154         0x8dc0, 0xffffffff, 0x98989898,
 155         0x8dc4, 0xffffffff, 0x98989898,
 156         0x8dc8, 0xffffffff, 0x98989898,
 157         0x8dcc, 0xffffffff, 0x98989898,
 158         0x88c4, 0xffffffff, 0x00000082
 159 };
 160
 161 static const u32 rv770_golden_registers[] =
 162 {
 163         0x562c, 0xffffffff, 0,
 164         0x3f90, 0xffffffff, 0,
 165         0x9148, 0xffffffff, 0,
 166         0x3f94, 0xffffffff, 0,
 167         0x914c, 0xffffffff, 0,
 168         0x9698, 0x18000000, 0x18000000
 169 };
 170
 171 static const u32 rv770ce_golden_registers[] =
 172 {
 173         0x562c, 0xffffffff, 0,
 174         0x3f90, 0xffffffff, 0x00cc0000,
 175         0x9148, 0xffffffff, 0x00cc0000,
 176         0x3f94, 0xffffffff, 0x00cc0000,
 177         0x914c, 0xffffffff, 0x00cc0000,
 178         0x9b7c, 0xffffffff, 0x00fa0000,
 179         0x3f8c, 0xffffffff, 0x00fa0000,
 180         0x9698, 0x18000000, 0x18000000
 181 };
 182
 183 static const u32 rv770_mgcg_init[] =
 184 {
 185         0x8bcc, 0xffffffff, 0x130300f9,
 186         0x5448, 0xffffffff, 0x100,
 187         0x55e4, 0xffffffff, 0x100,
 188         0x160c, 0xffffffff, 0x100,
 189         0x5644, 0xffffffff, 0x100,
 190         0xc164, 0xffffffff, 0x100,
 191         0x8a18, 0xffffffff, 0x100,
 192         0x897c, 0xffffffff, 0x8000100,
 193         0x8b28, 0xffffffff, 0x3c000100,
 194         0x9144, 0xffffffff, 0x100,
 195         0x9a1c, 0xffffffff, 0x10000,
 196         0x9a50, 0xffffffff, 0x100,
 197         0x9a1c, 0xffffffff, 0x10001,
 198         0x9a50, 0xffffffff, 0x100,
 199         0x9a1c, 0xffffffff, 0x10002,
 200         0x9a50, 0xffffffff, 0x100,
 201         0x9a1c, 0xffffffff, 0x10003,
 202         0x9a50, 0xffffffff, 0x100,
 203         0x9a1c, 0xffffffff, 0x0,
 204         0x9870, 0xffffffff, 0x100,
 205         0x8d58, 0xffffffff, 0x100,
 206         0x9500, 0xffffffff, 0x0,
 207         0x9510, 0xffffffff, 0x100,
 208         0x9500, 0xffffffff, 0x1,
 209         0x9510, 0xffffffff, 0x100,
 210         0x9500, 0xffffffff, 0x2,
 211         0x9510, 0xffffffff, 0x100,
 212         0x9500, 0xffffffff, 0x3,
 213         0x9510, 0xffffffff, 0x100,
 214         0x9500, 0xffffffff, 0x4,
 215         0x9510, 0xffffffff, 0x100,
 216         0x9500, 0xffffffff, 0x5,
 217         0x9510, 0xffffffff, 0x100,
 218         0x9500, 0xffffffff, 0x6,
 219         0x9510, 0xffffffff, 0x100,
 220         0x9500, 0xffffffff, 0x7,
 221         0x9510, 0xffffffff, 0x100,
 222         0x9500, 0xffffffff, 0x8,
 223         0x9510, 0xffffffff, 0x100,
 224         0x9500, 0xffffffff, 0x9,
 225         0x9510, 0xffffffff, 0x100,
 226         0x9500, 0xffffffff, 0x8000,
 227         0x9490, 0xffffffff, 0x0,
 228         0x949c, 0xffffffff, 0x100,
 229         0x9490, 0xffffffff, 0x1,
 230         0x949c, 0xffffffff, 0x100,
 231         0x9490, 0xffffffff, 0x2,
 232         0x949c, 0xffffffff, 0x100,
 233         0x9490, 0xffffffff, 0x3,
 234         0x949c, 0xffffffff, 0x100,
 235         0x9490, 0xffffffff, 0x4,
 236         0x949c, 0xffffffff, 0x100,
 237         0x9490, 0xffffffff, 0x5,
 238         0x949c, 0xffffffff, 0x100,
 239         0x9490, 0xffffffff, 0x6,
 240         0x949c, 0xffffffff, 0x100,
 241         0x9490, 0xffffffff, 0x7,
 242         0x949c, 0xffffffff, 0x100,
 243         0x9490, 0xffffffff, 0x8,
 244         0x949c, 0xffffffff, 0x100,
 245         0x9490, 0xffffffff, 0x9,
 246         0x949c, 0xffffffff, 0x100,
 247         0x9490, 0xffffffff, 0x8000,
 248         0x9604, 0xffffffff, 0x0,
 249         0x9654, 0xffffffff, 0x100,
 250         0x9604, 0xffffffff, 0x1,
 251         0x9654, 0xffffffff, 0x100,
 252         0x9604, 0xffffffff, 0x2,
 253         0x9654, 0xffffffff, 0x100,
 254         0x9604, 0xffffffff, 0x3,
 255         0x9654, 0xffffffff, 0x100,
 256         0x9604, 0xffffffff, 0x4,
 257         0x9654, 0xffffffff, 0x100,
 258         0x9604, 0xffffffff, 0x5,
 259         0x9654, 0xffffffff, 0x100,
 260         0x9604, 0xffffffff, 0x6,
 261         0x9654, 0xffffffff, 0x100,
 262         0x9604, 0xffffffff, 0x7,
 263         0x9654, 0xffffffff, 0x100,
 264         0x9604, 0xffffffff, 0x8,
 265         0x9654, 0xffffffff, 0x100,
 266         0x9604, 0xffffffff, 0x9,
 267         0x9654, 0xffffffff, 0x100,
 268         0x9604, 0xffffffff, 0x80000000,
 269         0x9030, 0xffffffff, 0x100,
 270         0x9034, 0xffffffff, 0x100,
 271         0x9038, 0xffffffff, 0x100,
 272         0x903c, 0xffffffff, 0x100,
 273         0x9040, 0xffffffff, 0x100,
 274         0xa200, 0xffffffff, 0x100,
 275         0xa204, 0xffffffff, 0x100,
 276         0xa208, 0xffffffff, 0x100,
 277         0xa20c, 0xffffffff, 0x100,
 278         0x971c, 0xffffffff, 0x100,
 279         0x915c, 0xffffffff, 0x00020001,
 280         0x9160, 0xffffffff, 0x00040003,
 281         0x916c, 0xffffffff, 0x00060005,
 282         0x9170, 0xffffffff, 0x00080007,
 283         0x9174, 0xffffffff, 0x000a0009,
 284         0x9178, 0xffffffff, 0x000c000b,
 285         0x917c, 0xffffffff, 0x000e000d,
 286         0x9180, 0xffffffff, 0x0010000f,
 287         0x918c, 0xffffffff, 0x00120011,
 288         0x9190, 0xffffffff, 0x00140013,
 289         0x9194, 0xffffffff, 0x00020001,
 290         0x9198, 0xffffffff, 0x00040003,
 291         0x919c, 0xffffffff, 0x00060005,
 292         0x91a8, 0xffffffff, 0x00080007,
 293         0x91ac, 0xffffffff, 0x000a0009,
 294         0x91b0, 0xffffffff, 0x000c000b,
 295         0x91b4, 0xffffffff, 0x000e000d,
 296         0x91b8, 0xffffffff, 0x0010000f,
 297         0x91c4, 0xffffffff, 0x00120011,
 298         0x91c8, 0xffffffff, 0x00140013,
 299         0x91cc, 0xffffffff, 0x00020001,
 300         0x91d0, 0xffffffff, 0x00040003,
 301         0x91d4, 0xffffffff, 0x00060005,
 302         0x91e0, 0xffffffff, 0x00080007,
 303         0x91e4, 0xffffffff, 0x000a0009,
 304         0x91e8, 0xffffffff, 0x000c000b,
 305         0x91ec, 0xffffffff, 0x00020001,
 306         0x91f0, 0xffffffff, 0x00040003,
 307         0x91f4, 0xffffffff, 0x00060005,
 308         0x9200, 0xffffffff, 0x00080007,
 309         0x9204, 0xffffffff, 0x000a0009,
 310         0x9208, 0xffffffff, 0x000c000b,
 311         0x920c, 0xffffffff, 0x000e000d,
 312         0x9210, 0xffffffff, 0x0010000f,
 313         0x921c, 0xffffffff, 0x00120011,
 314         0x9220, 0xffffffff, 0x00140013,
 315         0x9224, 0xffffffff, 0x00020001,
 316         0x9228, 0xffffffff, 0x00040003,
 317         0x922c, 0xffffffff, 0x00060005,
 318         0x9238, 0xffffffff, 0x00080007,
 319         0x923c, 0xffffffff, 0x000a0009,
 320         0x9240, 0xffffffff, 0x000c000b,
 321         0x9244, 0xffffffff, 0x000e000d,
 322         0x9248, 0xffffffff, 0x0010000f,
 323         0x9254, 0xffffffff, 0x00120011,
 324         0x9258, 0xffffffff, 0x00140013,
 325         0x925c, 0xffffffff, 0x00020001,
 326         0x9260, 0xffffffff, 0x00040003,
 327         0x9264, 0xffffffff, 0x00060005,
 328         0x9270, 0xffffffff, 0x00080007,
 329         0x9274, 0xffffffff, 0x000a0009,
 330         0x9278, 0xffffffff, 0x000c000b,
 331         0x927c, 0xffffffff, 0x000e000d,
 332         0x9280, 0xffffffff, 0x0010000f,
 333         0x928c, 0xffffffff, 0x00120011,
 334         0x9290, 0xffffffff, 0x00140013,
 335         0x9294, 0xffffffff, 0x00020001,
 336         0x929c, 0xffffffff, 0x00040003,
 337         0x92a0, 0xffffffff, 0x00060005,
 338         0x92a4, 0xffffffff, 0x00080007
 339 };
 340
 341 static const u32 rv710_golden_registers[] =
 342 {
 343         0x3f90, 0x00ff0000, 0x00fc0000,
 344         0x9148, 0x00ff0000, 0x00fc0000,
 345         0x3f94, 0x00ff0000, 0x00fc0000,
 346         0x914c, 0x00ff0000, 0x00fc0000,
 347         0xb4c, 0x00000020, 0x00000020,
 348         0xa180, 0xffffffff, 0x00003f3f
 349 };
 350
 351 static const u32 rv710_mgcg_init[] =
 352 {
 353         0x8bcc, 0xffffffff, 0x13030040,
 354         0x5448, 0xffffffff, 0x100,
 355         0x55e4, 0xffffffff, 0x100,
 356         0x160c, 0xffffffff, 0x100,
 357         0x5644, 0xffffffff, 0x100,
 358         0xc164, 0xffffffff, 0x100,
 359         0x8a18, 0xffffffff, 0x100,
 360         0x897c, 0xffffffff, 0x8000100,
 361         0x8b28, 0xffffffff, 0x3c000100,
 362         0x9144, 0xffffffff, 0x100,
 363         0x9a1c, 0xffffffff, 0x10000,
 364         0x9a50, 0xffffffff, 0x100,
 365         0x9a1c, 0xffffffff, 0x0,
 366         0x9870, 0xffffffff, 0x100,
 367         0x8d58, 0xffffffff, 0x100,
 368         0x9500, 0xffffffff, 0x0,
 369         0x9510, 0xffffffff, 0x100,
 370         0x9500, 0xffffffff, 0x1,
 371         0x9510, 0xffffffff, 0x100,
 372         0x9500, 0xffffffff, 0x8000,
 373         0x9490, 0xffffffff, 0x0,
 374         0x949c, 0xffffffff, 0x100,
 375         0x9490, 0xffffffff, 0x1,
 376         0x949c, 0xffffffff, 0x100,
 377         0x9490, 0xffffffff, 0x8000,
 378         0x9604, 0xffffffff, 0x0,
 379         0x9654, 0xffffffff, 0x100,
 380         0x9604, 0xffffffff, 0x1,
 381         0x9654, 0xffffffff, 0x100,
 382         0x9604, 0xffffffff, 0x80000000,
 383         0x9030, 0xffffffff, 0x100,
 384         0x9034, 0xffffffff, 0x100,
 385         0x9038, 0xffffffff, 0x100,
 386         0x903c, 0xffffffff, 0x100,
 387         0x9040, 0xffffffff, 0x100,
 388         0xa200, 0xffffffff, 0x100,
 389         0xa204, 0xffffffff, 0x100,
 390         0xa208, 0xffffffff, 0x100,
 391         0xa20c, 0xffffffff, 0x100,
 392         0x971c, 0xffffffff, 0x100,
 393         0x915c, 0xffffffff, 0x00020001,
 394         0x9174, 0xffffffff, 0x00000003,
 395         0x9178, 0xffffffff, 0x00050001,
 396         0x917c, 0xffffffff, 0x00030002,
 397         0x918c, 0xffffffff, 0x00000004,
 398         0x9190, 0xffffffff, 0x00070006,
 399         0x9194, 0xffffffff, 0x00050001,
 400         0x9198, 0xffffffff, 0x00030002,
 401         0x91a8, 0xffffffff, 0x00000004,
 402         0x91ac, 0xffffffff, 0x00070006,
 403         0x91e8, 0xffffffff, 0x00000001,
 404         0x9294, 0xffffffff, 0x00000001,
 405         0x929c, 0xffffffff, 0x00000002,
 406         0x92a0, 0xffffffff, 0x00040003,
 407         0x9150, 0xffffffff, 0x4d940000
 408 };
 409
 410 static const u32 rv730_golden_registers[] =
 411 {
 412         0x3f90, 0x00ff0000, 0x00f00000,
 413         0x9148, 0x00ff0000, 0x00f00000,
 414         0x3f94, 0x00ff0000, 0x00f00000,
 415         0x914c, 0x00ff0000, 0x00f00000,
 416         0x900c, 0xffffffff, 0x003b033f,
 417         0xb4c, 0x00000020, 0x00000020,
 418         0xa180, 0xffffffff, 0x00003f3f
 419 };
 420
 421 static const u32 rv730_mgcg_init[] =
 422 {
 423         0x8bcc, 0xffffffff, 0x130300f9,
 424         0x5448, 0xffffffff, 0x100,
 425         0x55e4, 0xffffffff, 0x100,
 426         0x160c, 0xffffffff, 0x100,
 427         0x5644, 0xffffffff, 0x100,
 428         0xc164, 0xffffffff, 0x100,
 429         0x8a18, 0xffffffff, 0x100,
 430         0x897c, 0xffffffff, 0x8000100,
 431         0x8b28, 0xffffffff, 0x3c000100,
 432         0x9144, 0xffffffff, 0x100,
 433         0x9a1c, 0xffffffff, 0x10000,
 434         0x9a50, 0xffffffff, 0x100,
 435         0x9a1c, 0xffffffff, 0x10001,
 436         0x9a50, 0xffffffff, 0x100,
 437         0x9a1c, 0xffffffff, 0x0,
 438         0x9870, 0xffffffff, 0x100,
 439         0x8d58, 0xffffffff, 0x100,
 440         0x9500, 0xffffffff, 0x0,
 441         0x9510, 0xffffffff, 0x100,
 442         0x9500, 0xffffffff, 0x1,
 443         0x9510, 0xffffffff, 0x100,
 444         0x9500, 0xffffffff, 0x2,
 445         0x9510, 0xffffffff, 0x100,
 446         0x9500, 0xffffffff, 0x3,
 447         0x9510, 0xffffffff, 0x100,
 448         0x9500, 0xffffffff, 0x4,
 449         0x9510, 0xffffffff, 0x100,
 450         0x9500, 0xffffffff, 0x5,
 451         0x9510, 0xffffffff, 0x100,
 452         0x9500, 0xffffffff, 0x6,
 453         0x9510, 0xffffffff, 0x100,
 454         0x9500, 0xffffffff, 0x7,
 455         0x9510, 0xffffffff, 0x100,
 456         0x9500, 0xffffffff, 0x8000,
 457         0x9490, 0xffffffff, 0x0,
 458         0x949c, 0xffffffff, 0x100,
 459         0x9490, 0xffffffff, 0x1,
 460         0x949c, 0xffffffff, 0x100,
 461         0x9490, 0xffffffff, 0x2,
 462         0x949c, 0xffffffff, 0x100,
 463         0x9490, 0xffffffff, 0x3,
 464         0x949c, 0xffffffff, 0x100,
 465         0x9490, 0xffffffff, 0x4,
 466         0x949c, 0xffffffff, 0x100,
 467         0x9490, 0xffffffff, 0x5,
 468         0x949c, 0xffffffff, 0x100,
 469         0x9490, 0xffffffff, 0x6,
 470         0x949c, 0xffffffff, 0x100,
 471         0x9490, 0xffffffff, 0x7,
 472         0x949c, 0xffffffff, 0x100,
 473         0x9490, 0xffffffff, 0x8000,
 474         0x9604, 0xffffffff, 0x0,
 475         0x9654, 0xffffffff, 0x100,
 476         0x9604, 0xffffffff, 0x1,
 477         0x9654, 0xffffffff, 0x100,
 478         0x9604, 0xffffffff, 0x2,
 479         0x9654, 0xffffffff, 0x100,
 480         0x9604, 0xffffffff, 0x3,
 481         0x9654, 0xffffffff, 0x100,
 482         0x9604, 0xffffffff, 0x4,
 483         0x9654, 0xffffffff, 0x100,
 484         0x9604, 0xffffffff, 0x5,
 485         0x9654, 0xffffffff, 0x100,
 486         0x9604, 0xffffffff, 0x6,
 487         0x9654, 0xffffffff, 0x100,
 488         0x9604, 0xffffffff, 0x7,
 489         0x9654, 0xffffffff, 0x100,
 490         0x9604, 0xffffffff, 0x80000000,
 491         0x9030, 0xffffffff, 0x100,
 492         0x9034, 0xffffffff, 0x100,
 493         0x9038, 0xffffffff, 0x100,
 494         0x903c, 0xffffffff, 0x100,
 495         0x9040, 0xffffffff, 0x100,
 496         0xa200, 0xffffffff, 0x100,
 497         0xa204, 0xffffffff, 0x100,
 498         0xa208, 0xffffffff, 0x100,
 499         0xa20c, 0xffffffff, 0x100,
 500         0x971c, 0xffffffff, 0x100,
 501         0x915c, 0xffffffff, 0x00020001,
 502         0x916c, 0xffffffff, 0x00040003,
 503         0x9170, 0xffffffff, 0x00000005,
 504         0x9178, 0xffffffff, 0x00050001,
 505         0x917c, 0xffffffff, 0x00030002,
 506         0x918c, 0xffffffff, 0x00000004,
 507         0x9190, 0xffffffff, 0x00070006,
 508         0x9194, 0xffffffff, 0x00050001,
 509         0x9198, 0xffffffff, 0x00030002,
 510         0x91a8, 0xffffffff, 0x00000004,
 511         0x91ac, 0xffffffff, 0x00070006,
 512         0x91b0, 0xffffffff, 0x00050001,
 513         0x91b4, 0xffffffff, 0x00030002,
 514         0x91c4, 0xffffffff, 0x00000004,
 515         0x91c8, 0xffffffff, 0x00070006,
 516         0x91cc, 0xffffffff, 0x00050001,
 517         0x91d0, 0xffffffff, 0x00030002,
 518         0x91e0, 0xffffffff, 0x00000004,
 519         0x91e4, 0xffffffff, 0x00070006,
 520         0x91e8, 0xffffffff, 0x00000001,
 521         0x91ec, 0xffffffff, 0x00050001,
 522         0x91f0, 0xffffffff, 0x00030002,
 523         0x9200, 0xffffffff, 0x00000004,
 524         0x9204, 0xffffffff, 0x00070006,
 525         0x9208, 0xffffffff, 0x00050001,
 526         0x920c, 0xffffffff, 0x00030002,
 527         0x921c, 0xffffffff, 0x00000004,
 528         0x9220, 0xffffffff, 0x00070006,
 529         0x9224, 0xffffffff, 0x00050001,
 530         0x9228, 0xffffffff, 0x00030002,
 531         0x9238, 0xffffffff, 0x00000004,
 532         0x923c, 0xffffffff, 0x00070006,
 533         0x9240, 0xffffffff, 0x00050001,
 534         0x9244, 0xffffffff, 0x00030002,
 535         0x9254, 0xffffffff, 0x00000004,
 536         0x9258, 0xffffffff, 0x00070006,
 537         0x9294, 0xffffffff, 0x00000001,
 538         0x929c, 0xffffffff, 0x00000002,
 539         0x92a0, 0xffffffff, 0x00040003,
 540         0x92a4, 0xffffffff, 0x00000005
 541 };
 542
 543 static const u32 rv740_golden_registers[] =
 544 {
 545         0x88c4, 0xffffffff, 0x00000082,
 546         0x28a50, 0xfffffffc, 0x00000004,
 547         0x2650, 0x00040000, 0,
 548         0x20bc, 0x00040000, 0,
 549         0x733c, 0xffffffff, 0x00000002,
 550         0x7300, 0xffffffff, 0x001000f0,
 551         0x3f90, 0x00ff0000, 0,
 552         0x9148, 0x00ff0000, 0,
 553         0x3f94, 0x00ff0000, 0,
 554         0x914c, 0x00ff0000, 0,
 555         0x240c, 0xffffffff, 0x00000380,
 556         0x8a14, 0x00000007, 0x00000007,
 557         0x8b24, 0xffffffff, 0x00ff0fff,
 558         0x28a4c, 0xffffffff, 0x00004000,
 559         0xa180, 0xffffffff, 0x00003f3f,
 560         0x8d00, 0xffffffff, 0x0e0e003a,
 561         0x8d04, 0xffffffff, 0x013a0e2a,
 562         0x8c00, 0xffffffff, 0xe400000f,
 563         0x8db0, 0xffffffff, 0x98989898,
 564         0x8db4, 0xffffffff, 0x98989898,
 565         0x8db8, 0xffffffff, 0x98989898,
 566         0x8dbc, 0xffffffff, 0x98989898,
 567         0x8dc0, 0xffffffff, 0x98989898,
 568         0x8dc4, 0xffffffff, 0x98989898,
 569         0x8dc8, 0xffffffff, 0x98989898,
 570         0x8dcc, 0xffffffff, 0x98989898,
 571         0x9058, 0xffffffff, 0x0fffc40f,
 572         0x900c, 0xffffffff, 0x003b033f,
 573         0x28350, 0xffffffff, 0,
 574         0x8cf0, 0x1fffffff, 0x08e00420,
 575         0x9508, 0xffffffff, 0x00000002,
 576         0x88c4, 0xffffffff, 0x000000c2,
 577         0x9698, 0x18000000, 0x18000000
 578 };
 579
 580 static const u32 rv740_mgcg_init[] =
 581 {
 582         0x8bcc, 0xffffffff, 0x13030100,
 583         0x5448, 0xffffffff, 0x100,
 584         0x55e4, 0xffffffff, 0x100,
 585         0x160c, 0xffffffff, 0x100,
 586         0x5644, 0xffffffff, 0x100,
 587         0xc164, 0xffffffff, 0x100,
 588         0x8a18, 0xffffffff, 0x100,
 589         0x897c, 0xffffffff, 0x100,
 590         0x8b28, 0xffffffff, 0x100,
 591         0x9144, 0xffffffff, 0x100,
 592         0x9a1c, 0xffffffff, 0x10000,
 593         0x9a50, 0xffffffff, 0x100,
 594         0x9a1c, 0xffffffff, 0x10001,
 595         0x9a50, 0xffffffff, 0x100,
 596         0x9a1c, 0xffffffff, 0x10002,
 597         0x9a50, 0xffffffff, 0x100,
 598         0x9a1c, 0xffffffff, 0x10003,
 599         0x9a50, 0xffffffff, 0x100,
 600         0x9a1c, 0xffffffff, 0x0,
 601         0x9870, 0xffffffff, 0x100,
 602         0x8d58, 0xffffffff, 0x100,
 603         0x9500, 0xffffffff, 0x0,
 604         0x9510, 0xffffffff, 0x100,
 605         0x9500, 0xffffffff, 0x1,
 606         0x9510, 0xffffffff, 0x100,
 607         0x9500, 0xffffffff, 0x2,
 608         0x9510, 0xffffffff, 0x100,
 609         0x9500, 0xffffffff, 0x3,
 610         0x9510, 0xffffffff, 0x100,
 611         0x9500, 0xffffffff, 0x4,
 612         0x9510, 0xffffffff, 0x100,
 613         0x9500, 0xffffffff, 0x5,
 614         0x9510, 0xffffffff, 0x100,
 615         0x9500, 0xffffffff, 0x6,
 616         0x9510, 0xffffffff, 0x100,
 617         0x9500, 0xffffffff, 0x7,
 618         0x9510, 0xffffffff, 0x100,
 619         0x9500, 0xffffffff, 0x8000,
 620         0x9490, 0xffffffff, 0x0,
 621         0x949c, 0xffffffff, 0x100,
 622         0x9490, 0xffffffff, 0x1,
 623         0x949c, 0xffffffff, 0x100,
 624         0x9490, 0xffffffff, 0x2,
 625         0x949c, 0xffffffff, 0x100,
 626         0x9490, 0xffffffff, 0x3,
 627         0x949c, 0xffffffff, 0x100,
 628         0x9490, 0xffffffff, 0x4,
 629         0x949c, 0xffffffff, 0x100,
 630         0x9490, 0xffffffff, 0x5,
 631         0x949c, 0xffffffff, 0x100,
 632         0x9490, 0xffffffff, 0x6,
 633         0x949c, 0xffffffff, 0x100,
 634         0x9490, 0xffffffff, 0x7,
 635         0x949c, 0xffffffff, 0x100,
 636         0x9490, 0xffffffff, 0x8000,
 637         0x9604, 0xffffffff, 0x0,
 638         0x9654, 0xffffffff, 0x100,
 639         0x9604, 0xffffffff, 0x1,
 640         0x9654, 0xffffffff, 0x100,
 641         0x9604, 0xffffffff, 0x2,
 642         0x9654, 0xffffffff, 0x100,
 643         0x9604, 0xffffffff, 0x3,
 644         0x9654, 0xffffffff, 0x100,
 645         0x9604, 0xffffffff, 0x4,
 646         0x9654, 0xffffffff, 0x100,
 647         0x9604, 0xffffffff, 0x5,
 648         0x9654, 0xffffffff, 0x100,
 649         0x9604, 0xffffffff, 0x6,
 650         0x9654, 0xffffffff, 0x100,
 651         0x9604, 0xffffffff, 0x7,
 652         0x9654, 0xffffffff, 0x100,
 653         0x9604, 0xffffffff, 0x80000000,
 654         0x9030, 0xffffffff, 0x100,
 655         0x9034, 0xffffffff, 0x100,
 656         0x9038, 0xffffffff, 0x100,
 657         0x903c, 0xffffffff, 0x100,
 658         0x9040, 0xffffffff, 0x100,
 659         0xa200, 0xffffffff, 0x100,
 660         0xa204, 0xffffffff, 0x100,
 661         0xa208, 0xffffffff, 0x100,
 662         0xa20c, 0xffffffff, 0x100,
 663         0x971c, 0xffffffff, 0x100,
 664         0x915c, 0xffffffff, 0x00020001,
 665         0x9160, 0xffffffff, 0x00040003,
 666         0x916c, 0xffffffff, 0x00060005,
 667         0x9170, 0xffffffff, 0x00080007,
 668         0x9174, 0xffffffff, 0x000a0009,
 669         0x9178, 0xffffffff, 0x000c000b,
 670         0x917c, 0xffffffff, 0x000e000d,
 671         0x9180, 0xffffffff, 0x0010000f,
 672         0x918c, 0xffffffff, 0x00120011,
 673         0x9190, 0xffffffff, 0x00140013,
 674         0x9194, 0xffffffff, 0x00020001,
 675         0x9198, 0xffffffff, 0x00040003,
 676         0x919c, 0xffffffff, 0x00060005,
 677         0x91a8, 0xffffffff, 0x00080007,
 678         0x91ac, 0xffffffff, 0x000a0009,
 679         0x91b0, 0xffffffff, 0x000c000b,
 680         0x91b4, 0xffffffff, 0x000e000d,
 681         0x91b8, 0xffffffff, 0x0010000f,
 682         0x91c4, 0xffffffff, 0x00120011,
 683         0x91c8, 0xffffffff, 0x00140013,
 684         0x91cc, 0xffffffff, 0x00020001,
 685         0x91d0, 0xffffffff, 0x00040003,
 686         0x91d4, 0xffffffff, 0x00060005,
 687         0x91e0, 0xffffffff, 0x00080007,
 688         0x91e4, 0xffffffff, 0x000a0009,
 689         0x91e8, 0xffffffff, 0x000c000b,
 690         0x91ec, 0xffffffff, 0x00020001,
 691         0x91f0, 0xffffffff, 0x00040003,
 692         0x91f4, 0xffffffff, 0x00060005,
 693         0x9200, 0xffffffff, 0x00080007,
 694         0x9204, 0xffffffff, 0x000a0009,
 695         0x9208, 0xffffffff, 0x000c000b,
 696         0x920c, 0xffffffff, 0x000e000d,
 697         0x9210, 0xffffffff, 0x0010000f,
 698         0x921c, 0xffffffff, 0x00120011,
 699         0x9220, 0xffffffff, 0x00140013,
 700         0x9224, 0xffffffff, 0x00020001,
 701         0x9228, 0xffffffff, 0x00040003,
 702         0x922c, 0xffffffff, 0x00060005,
 703         0x9238, 0xffffffff, 0x00080007,
 704         0x923c, 0xffffffff, 0x000a0009,
 705         0x9240, 0xffffffff, 0x000c000b,
 706         0x9244, 0xffffffff, 0x000e000d,
 707         0x9248, 0xffffffff, 0x0010000f,
 708         0x9254, 0xffffffff, 0x00120011,
 709         0x9258, 0xffffffff, 0x00140013,
 710         0x9294, 0xffffffff, 0x00020001,
 711         0x929c, 0xffffffff, 0x00040003,
 712         0x92a0, 0xffffffff, 0x00060005,
 713         0x92a4, 0xffffffff, 0x00080007
 714 };
 715
 716 static void rv770_init_golden_registers(struct radeon_device *rdev)
 717 {
 718         switch (rdev->family) {
 719         case CHIP_RV770:
 720                 radeon_program_register_sequence(rdev,
 721                                                  r7xx_golden_registers,
 722                                                  (const u32)ARRAY_SIZE(r7xx_golden_registers));
 723                 radeon_program_register_sequence(rdev,
 724                                                  r7xx_golden_dyn_gpr_registers,
 725                                                  (const u32)ARRAY_SIZE(r7xx_golden_dyn_gpr_registers));
 726                 if (rdev->pdev->device == 0x994e)
 727                         radeon_program_register_sequence(rdev,
 728                                                          rv770ce_golden_registers,
 729                                                          (const u32)ARRAY_SIZE(rv770ce_golden_registers));
 730                 else
 731                         radeon_program_register_sequence(rdev,
 732                                                          rv770_golden_registers,
 733                                                          (const u32)ARRAY_SIZE(rv770_golden_registers));
 734                 radeon_program_register_sequence(rdev,
 735                                                  rv770_mgcg_init,
 736                                                  (const u32)ARRAY_SIZE(rv770_mgcg_init));
 737                 break;
 738         case CHIP_RV730:
 739                 radeon_program_register_sequence(rdev,
 740                                                  r7xx_golden_registers,
 741                                                  (const u32)ARRAY_SIZE(r7xx_golden_registers));
 742                 radeon_program_register_sequence(rdev,
 743                                                  r7xx_golden_dyn_gpr_registers,
 744                                                  (const u32)ARRAY_SIZE(r7xx_golden_dyn_gpr_registers));
 745                 radeon_program_register_sequence(rdev,
 746                                                  rv730_golden_registers,
 747                                                  (const u32)ARRAY_SIZE(rv730_golden_registers));
 748                 radeon_program_register_sequence(rdev,
 749                                                  rv730_mgcg_init,
 750                                                  (const u32)ARRAY_SIZE(rv730_mgcg_init));
 751                 break;
 752         case CHIP_RV710:
 753                 radeon_program_register_sequence(rdev,
 754                                                  r7xx_golden_registers,
 755                                                  (const u32)ARRAY_SIZE(r7xx_golden_registers));
 756                 radeon_program_register_sequence(rdev,
 757                                                  r7xx_golden_dyn_gpr_registers,
 758                                                  (const u32)ARRAY_SIZE(r7xx_golden_dyn_gpr_registers));
 759                 radeon_program_register_sequence(rdev,
 760                                                  rv710_golden_registers,
 761                                                  (const u32)ARRAY_SIZE(rv710_golden_registers));
 762                 radeon_program_register_sequence(rdev,
 763                                                  rv710_mgcg_init,
 764                                                  (const u32)ARRAY_SIZE(rv710_mgcg_init));
 765                 break;
 766         case CHIP_RV740:
 767                 radeon_program_register_sequence(rdev,
 768                                                  rv740_golden_registers,
 769                                                  (const u32)ARRAY_SIZE(rv740_golden_registers));
 770                 radeon_program_register_sequence(rdev,
 771                                                  rv740_mgcg_init,
 772                                                  (const u32)ARRAY_SIZE(rv740_mgcg_init));
 773                 break;
 774         default:
 775                 break;
 776         }
 777 }
 778
 779 #define PCIE_BUS_CLK                10000
 780 #define TCLK                        (PCIE_BUS_CLK / 10)
 781
 782 /**
 783  * rv770_get_xclk - get the xclk
 784  *
 785  * @rdev: radeon_device pointer
 786  *
 787  * Returns the reference clock used by the gfx engine
 788  * (r7xx-cayman).
 789  */
 790 u32 rv770_get_xclk(struct radeon_device *rdev)
 791 {
 792         u32 reference_clock = rdev->clock.spll.reference_freq;
 793         u32 tmp = RREG32(CG_CLKPIN_CNTL);
 794
 795         if (tmp & MUX_TCLK_TO_XCLK)
 796                 return TCLK;
 797
 798         if (tmp & XTALIN_DIVIDE)
 799                 return reference_clock / 4;
 800
 801         return reference_clock;
 802 }
 803
 804 u32 rv770_page_flip(struct radeon_device *rdev, int crtc_id, u64 crtc_base)
 805 {
 806         struct radeon_crtc *radeon_crtc = rdev->mode_info.crtcs[crtc_id];
 807         u32 tmp = RREG32(AVIVO_D1GRPH_UPDATE + radeon_crtc->crtc_offset);
 808         int i;
 809
 810         /* Lock the graphics update lock */
 811         tmp |= AVIVO_D1GRPH_UPDATE_LOCK;
 812         WREG32(AVIVO_D1GRPH_UPDATE + radeon_crtc->crtc_offset, tmp);
 813
 814         /* update the scanout addresses */
 815         if (radeon_crtc->crtc_id) {
 816                 WREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS_HIGH, upper_32_bits(crtc_base));
 817                 WREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS_HIGH, upper_32_bits(crtc_base));
 818         } else {
 819                 WREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS_HIGH, upper_32_bits(crtc_base));
 820                 WREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS_HIGH, upper_32_bits(crtc_base));
 821         }
 822         WREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS + radeon_crtc->crtc_offset,
 823                (u32)crtc_base);
 824         WREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS + radeon_crtc->crtc_offset,
 825                (u32)crtc_base);
 826
 827         /* Wait for update_pending to go high. */
 828         for (i = 0; i < rdev->usec_timeout; i++) {
 829                 if (RREG32(AVIVO_D1GRPH_UPDATE + radeon_crtc->crtc_offset) & AVIVO_D1GRPH_SURFACE_UPDATE_PENDING)
 830                         break;
 831                 udelay(1);
 832         }
 833         DRM_DEBUG("Update pending now high. Unlocking vupdate_lock.\n");
 834
 835         /* Unlock the lock, so double-buffering can take place inside vblank */
 836         tmp &= ~AVIVO_D1GRPH_UPDATE_LOCK;
 837         WREG32(AVIVO_D1GRPH_UPDATE + radeon_crtc->crtc_offset, tmp);
 838
 839         /* Return current update_pending status: */
 840         return RREG32(AVIVO_D1GRPH_UPDATE + radeon_crtc->crtc_offset) & AVIVO_D1GRPH_SURFACE_UPDATE_PENDING;
 841 }
 842
 843 /* get temperature in millidegrees */
 844 int rv770_get_temp(struct radeon_device *rdev)
 845 {
 846         u32 temp = (RREG32(CG_MULT_THERMAL_STATUS) & ASIC_T_MASK) >>
 847                 ASIC_T_SHIFT;
 848         int actual_temp;
 849
 850         if (temp & 0x400)
 851                 actual_temp = -256;
 852         else if (temp & 0x200)
 853                 actual_temp = 255;
 854         else if (temp & 0x100) {
 855                 actual_temp = temp & 0x1ff;
 856                 actual_temp |= ~0x1ff;
 857         } else
 858                 actual_temp = temp & 0xff;
 859
 860         return (actual_temp * 1000) / 2;
 861 }
 862
 863 void rv770_pm_misc(struct radeon_device *rdev)
 864 {
 865         int req_ps_idx = rdev->pm.requested_power_state_index;
 866         int req_cm_idx = rdev->pm.requested_clock_mode_index;
 867         struct radeon_power_state *ps = &rdev->pm.power_state[req_ps_idx];
 868         struct radeon_voltage *voltage = &ps->clock_info[req_cm_idx].voltage;
 869
 870         if ((voltage->type == VOLTAGE_SW) && voltage->voltage) {
 871                 /* 0xff01 is a flag rather then an actual voltage */
 872                 if (voltage->voltage == 0xff01)
 873                         return;
 874                 if (voltage->voltage != rdev->pm.current_vddc) {
 875                         radeon_atom_set_voltage(rdev, voltage->voltage, SET_VOLTAGE_TYPE_ASIC_VDDC);
 876                         rdev->pm.current_vddc = voltage->voltage;
 877                         DRM_DEBUG("Setting: v: %d\n", voltage->voltage);
 878                 }
 879         }
 880 }
 881
 882 /*
 883  * GART
 884  */
 885 static int rv770_pcie_gart_enable(struct radeon_device *rdev)
 886 {
 887         u32 tmp;
 888         int r, i;
 889
 890         if (rdev->gart.robj == NULL) {
 891                 dev_err(rdev->dev, "No VRAM object for PCIE GART.\n");
 892                 return -EINVAL;
 893         }
 894         r = radeon_gart_table_vram_pin(rdev);
 895         if (r)
 896                 return r;
 897         radeon_gart_restore(rdev);
 898         /* Setup L2 cache */
 899         WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING |
 900                                 ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE |
 901                                 EFFECTIVE_L2_QUEUE_SIZE(7));
 902         WREG32(VM_L2_CNTL2, 0);
 903         WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
 904         /* Setup TLB control */
 905         tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING |
 906                 SYSTEM_ACCESS_MODE_NOT_IN_SYS |
 907                 SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU |
 908                 EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
 909         WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
 910         WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
 911         WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
 912         if (rdev->family == CHIP_RV740)
 913                 WREG32(MC_VM_MD_L1_TLB3_CNTL, tmp);
 914         WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
 915         WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
 916         WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
 917         WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
 918         WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12);
 919         WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, rdev->mc.gtt_end >> 12);
 920         WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12);
 921         WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) |
 922                                 RANGE_PROTECTION_FAULT_ENABLE_DEFAULT);
 923         WREG32(VM_CONTEXT0_PROTECTION_FAULT_DEFAULT_ADDR,
 924                         (u32)(rdev->dummy_page.addr >> 12));
 925         for (i = 1; i < 7; i++)
 926                 WREG32(VM_CONTEXT0_CNTL + (i * 4), 0);
 927
 928         r600_pcie_gart_tlb_flush(rdev);
 929         DRM_INFO("PCIE GART of %uM enabled (table at 0x%016llX).\n",
 930                  (unsigned)(rdev->mc.gtt_size >> 20),
 931                  (unsigned long long)rdev->gart.table_addr);
 932         rdev->gart.ready = true;
 933         return 0;
 934 }
 935
 936 static void rv770_pcie_gart_disable(struct radeon_device *rdev)
 937 {
 938         u32 tmp;
 939         int i;
 940
 941         /* Disable all tables */
 942         for (i = 0; i < 7; i++)
 943                 WREG32(VM_CONTEXT0_CNTL + (i * 4), 0);
 944
 945         /* Setup L2 cache */
 946         WREG32(VM_L2_CNTL, ENABLE_L2_FRAGMENT_PROCESSING |
 947                                 EFFECTIVE_L2_QUEUE_SIZE(7));
 948         WREG32(VM_L2_CNTL2, 0);
 949         WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
 950         /* Setup TLB control */
 951         tmp = EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
 952         WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
 953         WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
 954         WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
 955         WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
 956         WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
 957         WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
 958         WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
 959         radeon_gart_table_vram_unpin(rdev);
 960 }
 961
 962 static void rv770_pcie_gart_fini(struct radeon_device *rdev)
 963 {
 964         radeon_gart_fini(rdev);
 965         rv770_pcie_gart_disable(rdev);
 966         radeon_gart_table_vram_free(rdev);
 967 }
 968
 969
 970 static void rv770_agp_enable(struct radeon_device *rdev)
 971 {
 972         u32 tmp;
 973         int i;
 974
 975         /* Setup L2 cache */
 976         WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING |
 977                                 ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE |
 978                                 EFFECTIVE_L2_QUEUE_SIZE(7));
 979         WREG32(VM_L2_CNTL2, 0);
 980         WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
 981         /* Setup TLB control */
 982         tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING |
 983                 SYSTEM_ACCESS_MODE_NOT_IN_SYS |
 984                 SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU |
 985                 EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
 986         WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
 987         WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
 988         WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
 989         WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
 990         WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
 991         WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
 992         WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
 993         for (i = 0; i < 7; i++)
 994                 WREG32(VM_CONTEXT0_CNTL + (i * 4), 0);
 995 }
 996
 997 static void rv770_mc_program(struct radeon_device *rdev)
 998 {
 999         struct rv515_mc_save save;
1000         u32 tmp;
1001         int i, j;
1002
1003         /* Initialize HDP */
1004         for (i = 0, j = 0; i < 32; i++, j += 0x18) {
1005                 WREG32((0x2c14 + j), 0x00000000);
1006                 WREG32((0x2c18 + j), 0x00000000);
1007                 WREG32((0x2c1c + j), 0x00000000);
1008                 WREG32((0x2c20 + j), 0x00000000);
1009                 WREG32((0x2c24 + j), 0x00000000);
1010         }
1011         /* r7xx hw bug.  Read from HDP_DEBUG1 rather
1012          * than writing to HDP_REG_COHERENCY_FLUSH_CNTL
1013          */
1014         tmp = RREG32(HDP_DEBUG1);
1015
1016         rv515_mc_stop(rdev, &save);
1017         if (r600_mc_wait_for_idle(rdev)) {
1018                 dev_warn(rdev->dev, "Wait for MC idle timedout !\n");
1019         }
1020         /* Lockout access through VGA aperture*/
1021         WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE);
1022         /* Update configuration */
1023         if (rdev->flags & RADEON_IS_AGP) {
1024                 if (rdev->mc.vram_start < rdev->mc.gtt_start) {
1025                         /* VRAM before AGP */
1026                         WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR,
1027                                 rdev->mc.vram_start >> 12);
1028                         WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR,
1029                                 rdev->mc.gtt_end >> 12);
1030                 } else {
1031                         /* VRAM after AGP */
1032                         WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR,
1033                                 rdev->mc.gtt_start >> 12);
1034                         WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR,
1035                                 rdev->mc.vram_end >> 12);
1036                 }
1037         } else {
1038                 WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR,
1039                         rdev->mc.vram_start >> 12);
1040                 WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR,
1041                         rdev->mc.vram_end >> 12);
1042         }
1043         WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, rdev->vram_scratch.gpu_addr >> 12);
1044         tmp = ((rdev->mc.vram_end >> 24) & 0xFFFF) << 16;
1045         tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF);
1046         WREG32(MC_VM_FB_LOCATION, tmp);
1047         WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8));
1048         WREG32(HDP_NONSURFACE_INFO, (2 << 7));
1049         WREG32(HDP_NONSURFACE_SIZE, 0x3FFFFFFF);
1050         if (rdev->flags & RADEON_IS_AGP) {
1051                 WREG32(MC_VM_AGP_TOP, rdev->mc.gtt_end >> 16);
1052                 WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16);
1053                 WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22);
1054         } else {
1055                 WREG32(MC_VM_AGP_BASE, 0);
1056                 WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF);
1057                 WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF);
1058         }
1059         if (r600_mc_wait_for_idle(rdev)) {
1060                 dev_warn(rdev->dev, "Wait for MC idle timedout !\n");
1061         }
1062         rv515_mc_resume(rdev, &save);
1063         /* we need to own VRAM, so turn off the VGA renderer here
1064          * to stop it overwriting our objects */
1065         rv515_vga_render_disable(rdev);
1066 }
1067
1068
1069 /*
1070  * CP.
1071  */
1072 void r700_cp_stop(struct radeon_device *rdev)
1073 {
1074         radeon_ttm_set_active_vram_size(rdev, rdev->mc.visible_vram_size);
1075         WREG32(CP_ME_CNTL, (CP_ME_HALT | CP_PFP_HALT));
1076         WREG32(SCRATCH_UMSK, 0);
1077         rdev->ring[RADEON_RING_TYPE_GFX_INDEX].ready = false;
1078 }
1079
1080 static int rv770_cp_load_microcode(struct radeon_device *rdev)
1081 {
1082         const __be32 *fw_data;
1083         int i;
1084
1085         if (!rdev->me_fw || !rdev->pfp_fw)
1086                 return -EINVAL;
1087
1088         r700_cp_stop(rdev);
1089         WREG32(CP_RB_CNTL,
1090 #ifdef __BIG_ENDIAN
1091                BUF_SWAP_32BIT |
1092 #endif
1093                RB_NO_UPDATE | RB_BLKSZ(15) | RB_BUFSZ(3));
1094
1095         /* Reset cp */
1096         WREG32(GRBM_SOFT_RESET, SOFT_RESET_CP);
1097         RREG32(GRBM_SOFT_RESET);
1098         mdelay(15);
1099         WREG32(GRBM_SOFT_RESET, 0);
1100
1101         fw_data = (const __be32 *)rdev->pfp_fw->data;
1102         WREG32(CP_PFP_UCODE_ADDR, 0);
1103         for (i = 0; i < R700_PFP_UCODE_SIZE; i++)
1104                 WREG32(CP_PFP_UCODE_DATA, be32_to_cpup(fw_data++));
1105         WREG32(CP_PFP_UCODE_ADDR, 0);
1106
1107         fw_data = (const __be32 *)rdev->me_fw->data;
1108         WREG32(CP_ME_RAM_WADDR, 0);
1109         for (i = 0; i < R700_PM4_UCODE_SIZE; i++)
1110                 WREG32(CP_ME_RAM_DATA, be32_to_cpup(fw_data++));
1111
1112         WREG32(CP_PFP_UCODE_ADDR, 0);
1113         WREG32(CP_ME_RAM_WADDR, 0);
1114         WREG32(CP_ME_RAM_RADDR, 0);
1115         return 0;
1116 }
1117
1118 void r700_cp_fini(struct radeon_device *rdev)
1119 {
1120         struct radeon_ring *ring = &rdev->ring[RADEON_RING_TYPE_GFX_INDEX];
1121         r700_cp_stop(rdev);
1122         radeon_ring_fini(rdev, ring);
1123         radeon_scratch_free(rdev, ring->rptr_save_reg);
1124 }
1125
1126 /*
1127  * Core functions
1128  */
1129 static void rv770_gpu_init(struct radeon_device *rdev)
1130 {
1131         int i, j, num_qd_pipes;
1132         u32 ta_aux_cntl;
1133         u32 sx_debug_1;
1134         u32 smx_dc_ctl0;
1135         u32 db_debug3;
1136         u32 num_gs_verts_per_thread;
1137         u32 vgt_gs_per_es;
1138         u32 gs_prim_buffer_depth = 0;
1139         u32 sq_ms_fifo_sizes;
1140         u32 sq_config;
1141         u32 sq_thread_resource_mgmt;
1142         u32 hdp_host_path_cntl;
1143         u32 sq_dyn_gpr_size_simd_ab_0;
1144         u32 gb_tiling_config = 0;
1145         u32 cc_rb_backend_disable = 0;
1146         u32 cc_gc_shader_pipe_config = 0;
1147         u32 mc_arb_ramcfg;
1148         u32 db_debug4, tmp;
1149         u32 inactive_pipes, shader_pipe_config;
1150         u32 disabled_rb_mask;
1151         unsigned active_number;
1152
1153         /* setup chip specs */
1154         rdev->config.rv770.tiling_group_size = 256;
1155         switch (rdev->family) {
1156         case CHIP_RV770:
1157                 rdev->config.rv770.max_pipes = 4;
1158                 rdev->config.rv770.max_tile_pipes = 8;
1159                 rdev->config.rv770.max_simds = 10;
1160                 rdev->config.rv770.max_backends = 4;
1161                 rdev->config.rv770.max_gprs = 256;
1162                 rdev->config.rv770.max_threads = 248;
1163                 rdev->config.rv770.max_stack_entries = 512;
1164                 rdev->config.rv770.max_hw_contexts = 8;
1165                 rdev->config.rv770.max_gs_threads = 16 * 2;
1166                 rdev->config.rv770.sx_max_export_size = 128;
1167                 rdev->config.rv770.sx_max_export_pos_size = 16;
1168                 rdev->config.rv770.sx_max_export_smx_size = 112;
1169                 rdev->config.rv770.sq_num_cf_insts = 2;
1170
1171                 rdev->config.rv770.sx_num_of_sets = 7;
1172                 rdev->config.rv770.sc_prim_fifo_size = 0xF9;
1173                 rdev->config.rv770.sc_hiz_tile_fifo_size = 0x30;
1174                 rdev->config.rv770.sc_earlyz_tile_fifo_fize = 0x130;
1175                 break;
1176         case CHIP_RV730:
1177                 rdev->config.rv770.max_pipes = 2;
1178                 rdev->config.rv770.max_tile_pipes = 4;
1179                 rdev->config.rv770.max_simds = 8;
1180                 rdev->config.rv770.max_backends = 2;
1181                 rdev->config.rv770.max_gprs = 128;
1182                 rdev->config.rv770.max_threads = 248;
1183                 rdev->config.rv770.max_stack_entries = 256;
1184                 rdev->config.rv770.max_hw_contexts = 8;
1185                 rdev->config.rv770.max_gs_threads = 16 * 2;
1186                 rdev->config.rv770.sx_max_export_size = 256;
1187                 rdev->config.rv770.sx_max_export_pos_size = 32;
1188                 rdev->config.rv770.sx_max_export_smx_size = 224;
1189                 rdev->config.rv770.sq_num_cf_insts = 2;
1190
1191                 rdev->config.rv770.sx_num_of_sets = 7;
1192                 rdev->config.rv770.sc_prim_fifo_size = 0xf9;
1193                 rdev->config.rv770.sc_hiz_tile_fifo_size = 0x30;
1194                 rdev->config.rv770.sc_earlyz_tile_fifo_fize = 0x130;
1195                 if (rdev->config.rv770.sx_max_export_pos_size > 16) {
1196                         rdev->config.rv770.sx_max_export_pos_size -= 16;
1197                         rdev->config.rv770.sx_max_export_smx_size += 16;
1198                 }
1199                 break;
1200         case CHIP_RV710:
1201                 rdev->config.rv770.max_pipes = 2;
1202                 rdev->config.rv770.max_tile_pipes = 2;
1203                 rdev->config.rv770.max_simds = 2;
1204                 rdev->config.rv770.max_backends = 1;
1205                 rdev->config.rv770.max_gprs = 256;
1206                 rdev->config.rv770.max_threads = 192;
1207                 rdev->config.rv770.max_stack_entries = 256;
1208                 rdev->config.rv770.max_hw_contexts = 4;
1209                 rdev->config.rv770.max_gs_threads = 8 * 2;
1210                 rdev->config.rv770.sx_max_export_size = 128;
1211                 rdev->config.rv770.sx_max_export_pos_size = 16;
1212                 rdev->config.rv770.sx_max_export_smx_size = 112;
1213                 rdev->config.rv770.sq_num_cf_insts = 1;
1214
1215                 rdev->config.rv770.sx_num_of_sets = 7;
1216                 rdev->config.rv770.sc_prim_fifo_size = 0x40;
1217                 rdev->config.rv770.sc_hiz_tile_fifo_size = 0x30;
1218                 rdev->config.rv770.sc_earlyz_tile_fifo_fize = 0x130;
1219                 break;
1220         case CHIP_RV740:
1221                 rdev->config.rv770.max_pipes = 4;
1222                 rdev->config.rv770.max_tile_pipes = 4;
1223                 rdev->config.rv770.max_simds = 8;
1224                 rdev->config.rv770.max_backends = 4;
1225                 rdev->config.rv770.max_gprs = 256;
1226                 rdev->config.rv770.max_threads = 248;
1227                 rdev->config.rv770.max_stack_entries = 512;
1228                 rdev->config.rv770.max_hw_contexts = 8;
1229                 rdev->config.rv770.max_gs_threads = 16 * 2;
1230                 rdev->config.rv770.sx_max_export_size = 256;
1231                 rdev->config.rv770.sx_max_export_pos_size = 32;
1232                 rdev->config.rv770.sx_max_export_smx_size = 224;
1233                 rdev->config.rv770.sq_num_cf_insts = 2;
1234
1235                 rdev->config.rv770.sx_num_of_sets = 7;
1236                 rdev->config.rv770.sc_prim_fifo_size = 0x100;
1237                 rdev->config.rv770.sc_hiz_tile_fifo_size = 0x30;
1238                 rdev->config.rv770.sc_earlyz_tile_fifo_fize = 0x130;
1239
1240                 if (rdev->config.rv770.sx_max_export_pos_size > 16) {
1241                         rdev->config.rv770.sx_max_export_pos_size -= 16;
1242                         rdev->config.rv770.sx_max_export_smx_size += 16;
1243                 }
1244                 break;
1245         default:
1246                 break;
1247         }
1248
1249         /* Initialize HDP */
1250         j = 0;
1251         for (i = 0; i < 32; i++) {
1252                 WREG32((0x2c14 + j), 0x00000000);
1253                 WREG32((0x2c18 + j), 0x00000000);
1254                 WREG32((0x2c1c + j), 0x00000000);
1255                 WREG32((0x2c20 + j), 0x00000000);
1256                 WREG32((0x2c24 + j), 0x00000000);
1257                 j += 0x18;
1258         }
1259
1260         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
1261
1262         /* setup tiling, simd, pipe config */
1263         mc_arb_ramcfg = RREG32(MC_ARB_RAMCFG);
1264
1265         shader_pipe_config = RREG32(CC_GC_SHADER_PIPE_CONFIG);
1266         inactive_pipes = (shader_pipe_config & INACTIVE_QD_PIPES_MASK) >> INACTIVE_QD_PIPES_SHIFT;
1267         for (i = 0, tmp = 1, active_number = 0; i < R7XX_MAX_PIPES; i++) {
1268                 if (!(inactive_pipes & tmp)) {
1269                         active_number++;
1270                 }
1271                 tmp <<= 1;
1272         }
1273         if (active_number == 1) {
1274                 WREG32(SPI_CONFIG_CNTL, DISABLE_INTERP_1);
1275         } else {
1276                 WREG32(SPI_CONFIG_CNTL, 0);
1277         }
1278
1279         cc_rb_backend_disable = RREG32(CC_RB_BACKEND_DISABLE) & 0x00ff0000;
1280         tmp = R7XX_MAX_BACKENDS - r600_count_pipe_bits(cc_rb_backend_disable >> 16);
1281         if (tmp < rdev->config.rv770.max_backends) {
1282                 rdev->config.rv770.max_backends = tmp;
1283         }
1284
1285         cc_gc_shader_pipe_config = RREG32(CC_GC_SHADER_PIPE_CONFIG) & 0xffffff00;
1286         tmp = R7XX_MAX_PIPES - r600_count_pipe_bits((cc_gc_shader_pipe_config >> 8) & R7XX_MAX_PIPES_MASK);
1287         if (tmp < rdev->config.rv770.max_pipes) {
1288                 rdev->config.rv770.max_pipes = tmp;
1289         }
1290         tmp = R7XX_MAX_SIMDS - r600_count_pipe_bits((cc_gc_shader_pipe_config >> 16) & R7XX_MAX_SIMDS_MASK);
1291         if (tmp < rdev->config.rv770.max_simds) {
1292                 rdev->config.rv770.max_simds = tmp;
1293         }
1294
1295         switch (rdev->config.rv770.max_tile_pipes) {
1296         case 1:
1297         default:
1298                 gb_tiling_config = PIPE_TILING(0);
1299                 break;
1300         case 2:
1301                 gb_tiling_config = PIPE_TILING(1);
1302                 break;
1303         case 4:
1304                 gb_tiling_config = PIPE_TILING(2);
1305                 break;
1306         case 8:
1307                 gb_tiling_config = PIPE_TILING(3);
1308                 break;
1309         }
1310         rdev->config.rv770.tiling_npipes = rdev->config.rv770.max_tile_pipes;
1311
1312         disabled_rb_mask = (RREG32(CC_RB_BACKEND_DISABLE) >> 16) & R7XX_MAX_BACKENDS_MASK;
1313         tmp = (gb_tiling_config & PIPE_TILING__MASK) >> PIPE_TILING__SHIFT;
1314         tmp = r6xx_remap_render_backend(rdev, tmp, rdev->config.rv770.max_backends,
1315                                         R7XX_MAX_BACKENDS, disabled_rb_mask);
1316         gb_tiling_config |= tmp << 16;
1317         rdev->config.rv770.backend_map = tmp;
1318
1319         if (rdev->family == CHIP_RV770)
1320                 gb_tiling_config |= BANK_TILING(1);
1321         else {
1322                 if ((mc_arb_ramcfg & NOOFBANK_MASK) >> NOOFBANK_SHIFT)
1323                         gb_tiling_config |= BANK_TILING(1);
1324                 else
1325                         gb_tiling_config |= BANK_TILING(0);
1326         }
1327         rdev->config.rv770.tiling_nbanks = 4 << ((gb_tiling_config >> 4) & 0x3);
1328         gb_tiling_config |= GROUP_SIZE((mc_arb_ramcfg & BURSTLENGTH_MASK) >> BURSTLENGTH_SHIFT);
1329         if (((mc_arb_ramcfg & NOOFROWS_MASK) >> NOOFROWS_SHIFT) > 3) {
1330                 gb_tiling_config |= ROW_TILING(3);
1331                 gb_tiling_config |= SAMPLE_SPLIT(3);
1332         } else {
1333                 gb_tiling_config |=
1334                         ROW_TILING(((mc_arb_ramcfg & NOOFROWS_MASK) >> NOOFROWS_SHIFT));
1335                 gb_tiling_config |=
1336                         SAMPLE_SPLIT(((mc_arb_ramcfg & NOOFROWS_MASK) >> NOOFROWS_SHIFT));
1337         }
1338
1339         gb_tiling_config |= BANK_SWAPS(1);
1340         rdev->config.rv770.tile_config = gb_tiling_config;
1341
1342         WREG32(GB_TILING_CONFIG, gb_tiling_config);
1343         WREG32(DCP_TILING_CONFIG, (gb_tiling_config & 0xffff));
1344         WREG32(HDP_TILING_CONFIG, (gb_tiling_config & 0xffff));
1345         WREG32(DMA_TILING_CONFIG, (gb_tiling_config & 0xffff));
1346         WREG32(DMA_TILING_CONFIG2, (gb_tiling_config & 0xffff));
1347         if (rdev->family == CHIP_RV730) {
1348                 WREG32(UVD_UDEC_DB_TILING_CONFIG, (gb_tiling_config & 0xffff));
1349                 WREG32(UVD_UDEC_DBW_TILING_CONFIG, (gb_tiling_config & 0xffff));
1350                 WREG32(UVD_UDEC_TILING_CONFIG, (gb_tiling_config & 0xffff));
1351         }
1352
1353         WREG32(CGTS_SYS_TCC_DISABLE, 0);
1354         WREG32(CGTS_TCC_DISABLE, 0);
1355         WREG32(CGTS_USER_SYS_TCC_DISABLE, 0);
1356         WREG32(CGTS_USER_TCC_DISABLE, 0);
1357
1358
1359         num_qd_pipes = R7XX_MAX_PIPES - r600_count_pipe_bits((cc_gc_shader_pipe_config & INACTIVE_QD_PIPES_MASK) >> 8);
1360         WREG32(VGT_OUT_DEALLOC_CNTL, (num_qd_pipes * 4) & DEALLOC_DIST_MASK);
1361         WREG32(VGT_VERTEX_REUSE_BLOCK_CNTL, ((num_qd_pipes * 4) - 2) & VTX_REUSE_DEPTH_MASK);
1362
1363         /* set HW defaults for 3D engine */
1364         WREG32(CP_QUEUE_THRESHOLDS, (ROQ_IB1_START(0x16) |
1365                                      ROQ_IB2_START(0x2b)));
1366
1367         WREG32(CP_MEQ_THRESHOLDS, STQ_SPLIT(0x30));
1368
1369         ta_aux_cntl = RREG32(TA_CNTL_AUX);
1370         WREG32(TA_CNTL_AUX, ta_aux_cntl | DISABLE_CUBE_ANISO);
1371
1372         sx_debug_1 = RREG32(SX_DEBUG_1);
1373         sx_debug_1 |= ENABLE_NEW_SMX_ADDRESS;
1374         WREG32(SX_DEBUG_1, sx_debug_1);
1375
1376         smx_dc_ctl0 = RREG32(SMX_DC_CTL0);
1377         smx_dc_ctl0 &= ~CACHE_DEPTH(0x1ff);
1378         smx_dc_ctl0 |= CACHE_DEPTH((rdev->config.rv770.sx_num_of_sets * 64) - 1);
1379         WREG32(SMX_DC_CTL0, smx_dc_ctl0);
1380
1381         if (rdev->family != CHIP_RV740)
1382                 WREG32(SMX_EVENT_CTL, (ES_FLUSH_CTL(4) |
1383                                        GS_FLUSH_CTL(4) |
1384                                        ACK_FLUSH_CTL(3) |
1385                                        SYNC_FLUSH_CTL));
1386
1387         if (rdev->family != CHIP_RV770)
1388                 WREG32(SMX_SAR_CTL0, 0x00003f3f);
1389
1390         db_debug3 = RREG32(DB_DEBUG3);
1391         db_debug3 &= ~DB_CLK_OFF_DELAY(0x1f);
1392         switch (rdev->family) {
1393         case CHIP_RV770:
1394         case CHIP_RV740:
1395                 db_debug3 |= DB_CLK_OFF_DELAY(0x1f);
1396                 break;
1397         case CHIP_RV710:
1398         case CHIP_RV730:
1399         default:
1400                 db_debug3 |= DB_CLK_OFF_DELAY(2);
1401                 break;
1402         }
1403         WREG32(DB_DEBUG3, db_debug3);
1404
1405         if (rdev->family != CHIP_RV770) {
1406                 db_debug4 = RREG32(DB_DEBUG4);
1407                 db_debug4 |= DISABLE_TILE_COVERED_FOR_PS_ITER;
1408                 WREG32(DB_DEBUG4, db_debug4);
1409         }
1410
1411         WREG32(SX_EXPORT_BUFFER_SIZES, (COLOR_BUFFER_SIZE((rdev->config.rv770.sx_max_export_size / 4) - 1) |
1412                                         POSITION_BUFFER_SIZE((rdev->config.rv770.sx_max_export_pos_size / 4) - 1) |
1413                                         SMX_BUFFER_SIZE((rdev->config.rv770.sx_max_export_smx_size / 4) - 1)));
1414
1415         WREG32(PA_SC_FIFO_SIZE, (SC_PRIM_FIFO_SIZE(rdev->config.rv770.sc_prim_fifo_size) |
1416                                  SC_HIZ_TILE_FIFO_SIZE(rdev->config.rv770.sc_hiz_tile_fifo_size) |
1417                                  SC_EARLYZ_TILE_FIFO_SIZE(rdev->config.rv770.sc_earlyz_tile_fifo_fize)));
1418
1419         WREG32(PA_SC_MULTI_CHIP_CNTL, 0);
1420
1421         WREG32(VGT_NUM_INSTANCES, 1);
1422
1423         WREG32(SPI_CONFIG_CNTL_1, VTX_DONE_DELAY(4));
1424
1425         WREG32(CP_PERFMON_CNTL, 0);
1426
1427         sq_ms_fifo_sizes = (CACHE_FIFO_SIZE(16 * rdev->config.rv770.sq_num_cf_insts) |
1428                             DONE_FIFO_HIWATER(0xe0) |
1429                             ALU_UPDATE_FIFO_HIWATER(0x8));
1430         switch (rdev->family) {
1431         case CHIP_RV770:
1432         case CHIP_RV730:
1433         case CHIP_RV710:
1434                 sq_ms_fifo_sizes |= FETCH_FIFO_HIWATER(0x1);
1435                 break;
1436         case CHIP_RV740:
1437         default:
1438                 sq_ms_fifo_sizes |= FETCH_FIFO_HIWATER(0x4);
1439                 break;
1440         }
1441         WREG32(SQ_MS_FIFO_SIZES, sq_ms_fifo_sizes);
1442
1443         /* SQ_CONFIG, SQ_GPR_RESOURCE_MGMT, SQ_THREAD_RESOURCE_MGMT, SQ_STACK_RESOURCE_MGMT
1444          * should be adjusted as needed by the 2D/3D drivers.  This just sets default values
1445          */
1446         sq_config = RREG32(SQ_CONFIG);
1447         sq_config &= ~(PS_PRIO(3) |
1448                        VS_PRIO(3) |
1449                        GS_PRIO(3) |
1450                        ES_PRIO(3));
1451         sq_config |= (DX9_CONSTS |
1452                       VC_ENABLE |
1453                       EXPORT_SRC_C |
1454                       PS_PRIO(0) |
1455                       VS_PRIO(1) |
1456                       GS_PRIO(2) |
1457                       ES_PRIO(3));
1458         if (rdev->family == CHIP_RV710)
1459                 /* no vertex cache */
1460                 sq_config &= ~VC_ENABLE;
1461
1462         WREG32(SQ_CONFIG, sq_config);
1463
1464         WREG32(SQ_GPR_RESOURCE_MGMT_1,  (NUM_PS_GPRS((rdev->config.rv770.max_gprs * 24)/64) |
1465                                          NUM_VS_GPRS((rdev->config.rv770.max_gprs * 24)/64) |
1466                                          NUM_CLAUSE_TEMP_GPRS(((rdev->config.rv770.max_gprs * 24)/64)/2)));
1467
1468         WREG32(SQ_GPR_RESOURCE_MGMT_2,  (NUM_GS_GPRS((rdev->config.rv770.max_gprs * 7)/64) |
1469                                          NUM_ES_GPRS((rdev->config.rv770.max_gprs * 7)/64)));
1470
1471         sq_thread_resource_mgmt = (NUM_PS_THREADS((rdev->config.rv770.max_threads * 4)/8) |
1472                                    NUM_VS_THREADS((rdev->config.rv770.max_threads * 2)/8) |
1473                                    NUM_ES_THREADS((rdev->config.rv770.max_threads * 1)/8));
1474         if (((rdev->config.rv770.max_threads * 1) / 8) > rdev->config.rv770.max_gs_threads)
1475                 sq_thread_resource_mgmt |= NUM_GS_THREADS(rdev->config.rv770.max_gs_threads);
1476         else
1477                 sq_thread_resource_mgmt |= NUM_GS_THREADS((rdev->config.rv770.max_gs_threads * 1)/8);
1478         WREG32(SQ_THREAD_RESOURCE_MGMT, sq_thread_resource_mgmt);
1479
1480         WREG32(SQ_STACK_RESOURCE_MGMT_1, (NUM_PS_STACK_ENTRIES((rdev->config.rv770.max_stack_entries * 1)/4) |
1481                                                      NUM_VS_STACK_ENTRIES((rdev->config.rv770.max_stack_entries * 1)/4)));
1482
1483         WREG32(SQ_STACK_RESOURCE_MGMT_2, (NUM_GS_STACK_ENTRIES((rdev->config.rv770.max_stack_entries * 1)/4) |
1484                                                      NUM_ES_STACK_ENTRIES((rdev->config.rv770.max_stack_entries * 1)/4)));
1485
1486         sq_dyn_gpr_size_simd_ab_0 = (SIMDA_RING0((rdev->config.rv770.max_gprs * 38)/64) |
1487                                      SIMDA_RING1((rdev->config.rv770.max_gprs * 38)/64) |
1488                                      SIMDB_RING0((rdev->config.rv770.max_gprs * 38)/64) |
1489                                      SIMDB_RING1((rdev->config.rv770.max_gprs * 38)/64));
1490
1491         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_0, sq_dyn_gpr_size_simd_ab_0);
1492         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_1, sq_dyn_gpr_size_simd_ab_0);
1493         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_2, sq_dyn_gpr_size_simd_ab_0);
1494         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_3, sq_dyn_gpr_size_simd_ab_0);
1495         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_4, sq_dyn_gpr_size_simd_ab_0);
1496         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_5, sq_dyn_gpr_size_simd_ab_0);
1497         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_6, sq_dyn_gpr_size_simd_ab_0);
1498         WREG32(SQ_DYN_GPR_SIZE_SIMD_AB_7, sq_dyn_gpr_size_simd_ab_0);
1499
1500         WREG32(PA_SC_FORCE_EOV_MAX_CNTS, (FORCE_EOV_MAX_CLK_CNT(4095) |
1501                                           FORCE_EOV_MAX_REZ_CNT(255)));
1502
1503         if (rdev->family == CHIP_RV710)
1504                 WREG32(VGT_CACHE_INVALIDATION, (CACHE_INVALIDATION(TC_ONLY) |
1505                                                 AUTO_INVLD_EN(ES_AND_GS_AUTO)));
1506         else
1507                 WREG32(VGT_CACHE_INVALIDATION, (CACHE_INVALIDATION(VC_AND_TC) |
1508                                                 AUTO_INVLD_EN(ES_AND_GS_AUTO)));
1509
1510         switch (rdev->family) {
1511         case CHIP_RV770:
1512         case CHIP_RV730:
1513         case CHIP_RV740:
1514                 gs_prim_buffer_depth = 384;
1515                 break;
1516         case CHIP_RV710:
1517                 gs_prim_buffer_depth = 128;
1518                 break;
1519         default:
1520                 break;
1521         }
1522
1523         num_gs_verts_per_thread = rdev->config.rv770.max_pipes * 16;
1524         vgt_gs_per_es = gs_prim_buffer_depth + num_gs_verts_per_thread;
1525         /* Max value for this is 256 */
1526         if (vgt_gs_per_es > 256)
1527                 vgt_gs_per_es = 256;
1528
1529         WREG32(VGT_ES_PER_GS, 128);
1530         WREG32(VGT_GS_PER_ES, vgt_gs_per_es);
1531         WREG32(VGT_GS_PER_VS, 2);
1532
1533         /* more default values. 2D/3D driver should adjust as needed */
1534         WREG32(VGT_GS_VERTEX_REUSE, 16);
1535         WREG32(PA_SC_LINE_STIPPLE_STATE, 0);
1536         WREG32(VGT_STRMOUT_EN, 0);
1537         WREG32(SX_MISC, 0);
1538         WREG32(PA_SC_MODE_CNTL, 0);
1539         WREG32(PA_SC_EDGERULE, 0xaaaaaaaa);
1540         WREG32(PA_SC_AA_CONFIG, 0);
1541         WREG32(PA_SC_CLIPRECT_RULE, 0xffff);
1542         WREG32(PA_SC_LINE_STIPPLE, 0);
1543         WREG32(SPI_INPUT_Z, 0);
1544         WREG32(SPI_PS_IN_CONTROL_0, NUM_INTERP(2));
1545         WREG32(CB_COLOR7_FRAG, 0);
1546
1547         /* clear render buffer base addresses */
1548         WREG32(CB_COLOR0_BASE, 0);
1549         WREG32(CB_COLOR1_BASE, 0);
1550         WREG32(CB_COLOR2_BASE, 0);
1551         WREG32(CB_COLOR3_BASE, 0);
1552         WREG32(CB_COLOR4_BASE, 0);
1553         WREG32(CB_COLOR5_BASE, 0);
1554         WREG32(CB_COLOR6_BASE, 0);
1555         WREG32(CB_COLOR7_BASE, 0);
1556
1557         WREG32(TCP_CNTL, 0);
1558
1559         hdp_host_path_cntl = RREG32(HDP_HOST_PATH_CNTL);
1560         WREG32(HDP_HOST_PATH_CNTL, hdp_host_path_cntl);
1561
1562         WREG32(PA_SC_MULTI_CHIP_CNTL, 0);
1563
1564         WREG32(PA_CL_ENHANCE, (CLIP_VTX_REORDER_ENA |
1565                                           NUM_CLIP_SEQ(3)));
1566         WREG32(VC_ENHANCE, 0);
1567 }
1568
1569 void r700_vram_gtt_location(struct radeon_device *rdev, struct radeon_mc *mc)
1570 {
1571         u64 size_bf, size_af;
1572
1573         if (mc->mc_vram_size > 0xE0000000) {
1574                 /* leave room for at least 512M GTT */
1575                 dev_warn(rdev->dev, "limiting VRAM\n");
1576                 mc->real_vram_size = 0xE0000000;
1577                 mc->mc_vram_size = 0xE0000000;
1578         }
1579         if (rdev->flags & RADEON_IS_AGP) {
1580                 size_bf = mc->gtt_start;
1581                 size_af = mc->mc_mask - mc->gtt_end;
1582                 if (size_bf > size_af) {
1583                         if (mc->mc_vram_size > size_bf) {
1584                                 dev_warn(rdev->dev, "limiting VRAM\n");
1585                                 mc->real_vram_size = size_bf;
1586                                 mc->mc_vram_size = size_bf;
1587                         }
1588                         mc->vram_start = mc->gtt_start - mc->mc_vram_size;
1589                 } else {
1590                         if (mc->mc_vram_size > size_af) {
1591                                 dev_warn(rdev->dev, "limiting VRAM\n");
1592                                 mc->real_vram_size = size_af;
1593                                 mc->mc_vram_size = size_af;
1594                         }
1595                         mc->vram_start = mc->gtt_end + 1;
1596                 }
1597                 mc->vram_end = mc->vram_start + mc->mc_vram_size - 1;
1598                 dev_info(rdev->dev, "VRAM: %lluM 0x%08llX - 0x%08llX (%lluM used)\n",
1599                                 mc->mc_vram_size >> 20, mc->vram_start,
1600                                 mc->vram_end, mc->real_vram_size >> 20);
1601         } else {
1602                 radeon_vram_location(rdev, &rdev->mc, 0);
1603                 rdev->mc.gtt_base_align = 0;
1604                 radeon_gtt_location(rdev, mc);
1605         }
1606 }
1607
1608 static int rv770_mc_init(struct radeon_device *rdev)
1609 {
1610         u32 tmp;
1611         int chansize, numchan;
1612
1613         /* Get VRAM informations */
1614         rdev->mc.vram_is_ddr = true;
1615         tmp = RREG32(MC_ARB_RAMCFG);
1616         if (tmp & CHANSIZE_OVERRIDE) {
1617                 chansize = 16;
1618         } else if (tmp & CHANSIZE_MASK) {
1619                 chansize = 64;
1620         } else {
1621                 chansize = 32;
1622         }
1623         tmp = RREG32(MC_SHARED_CHMAP);
1624         switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) {
1625         case 0:
1626         default:
1627                 numchan = 1;
1628                 break;
1629         case 1:
1630                 numchan = 2;
1631                 break;
1632         case 2:
1633                 numchan = 4;
1634                 break;
1635         case 3:
1636                 numchan = 8;
1637                 break;
1638         }
1639         rdev->mc.vram_width = numchan * chansize;
1640         /* Could aper size report 0 ? */
1641         rdev->mc.aper_base = pci_resource_start(rdev->pdev, 0);
1642         rdev->mc.aper_size = pci_resource_len(rdev->pdev, 0);
1643         /* Setup GPU memory space */
1644         rdev->mc.mc_vram_size = RREG32(CONFIG_MEMSIZE);
1645         rdev->mc.real_vram_size = RREG32(CONFIG_MEMSIZE);
1646         rdev->mc.visible_vram_size = rdev->mc.aper_size;
1647         r700_vram_gtt_location(rdev, &rdev->mc);
1648         radeon_update_bandwidth_info(rdev);
1649
1650         return 0;
1651 }
1652
1653 static int rv770_startup(struct radeon_device *rdev)
1654 {
1655         struct radeon_ring *ring;
1656         int r;
1657
1658         /* enable pcie gen2 link */
1659         rv770_pcie_gen2_enable(rdev);
1660
1661         /* scratch needs to be initialized before MC */
1662         r = r600_vram_scratch_init(rdev);
1663         if (r)
1664                 return r;
1665
1666         rv770_mc_program(rdev);
1667
1668         if (!rdev->me_fw || !rdev->pfp_fw || !rdev->rlc_fw) {
1669                 r = r600_init_microcode(rdev);
1670                 if (r) {
1671                         DRM_ERROR("Failed to load firmware!\n");
1672                         return r;
1673                 }
1674         }
1675
1676         if (rdev->flags & RADEON_IS_AGP) {
1677                 rv770_agp_enable(rdev);
1678         } else {
1679                 r = rv770_pcie_gart_enable(rdev);
1680                 if (r)
1681                         return r;
1682         }
1683
1684         rv770_gpu_init(rdev);
1685
1686         /* allocate wb buffer */
1687         r = radeon_wb_init(rdev);
1688         if (r)
1689                 return r;
1690
1691         r = radeon_fence_driver_start_ring(rdev, RADEON_RING_TYPE_GFX_INDEX);
1692         if (r) {
1693                 dev_err(rdev->dev, "failed initializing CP fences (%d).\n", r);
1694                 return r;
1695         }
1696
1697         r = radeon_fence_driver_start_ring(rdev, R600_RING_TYPE_DMA_INDEX);
1698         if (r) {
1699                 dev_err(rdev->dev, "failed initializing DMA fences (%d).\n", r);
1700                 return r;
1701         }
1702
1703         r = uvd_v2_2_resume(rdev);
1704         if (!r) {
1705                 r = radeon_fence_driver_start_ring(rdev,
1706                                                    R600_RING_TYPE_UVD_INDEX);
1707                 if (r)
1708                         dev_err(rdev->dev, "UVD fences init error (%d).\n", r);
1709         }
1710
1711         if (r)
1712                 rdev->ring[R600_RING_TYPE_UVD_INDEX].ring_size = 0;
1713
1714         /* Enable IRQ */
1715         if (!rdev->irq.installed) {
1716                 r = radeon_irq_kms_init(rdev);
1717                 if (r)
1718                         return r;
1719         }
1720
1721         r = r600_irq_init(rdev);
1722         if (r) {
1723                 DRM_ERROR("radeon: IH init failed (%d).\n", r);
1724                 radeon_irq_kms_fini(rdev);
1725                 return r;
1726         }
1727         r600_irq_set(rdev);
1728
1729         ring = &rdev->ring[RADEON_RING_TYPE_GFX_INDEX];
1730         r = radeon_ring_init(rdev, ring, ring->ring_size, RADEON_WB_CP_RPTR_OFFSET,
1731                              R600_CP_RB_RPTR, R600_CP_RB_WPTR,
1732                              RADEON_CP_PACKET2);
1733         if (r)
1734                 return r;
1735
1736         ring = &rdev->ring[R600_RING_TYPE_DMA_INDEX];
1737         r = radeon_ring_init(rdev, ring, ring->ring_size, R600_WB_DMA_RPTR_OFFSET,
1738                              DMA_RB_RPTR, DMA_RB_WPTR,
1739                              DMA_PACKET(DMA_PACKET_NOP, 0, 0, 0));
1740         if (r)
1741                 return r;
1742
1743         r = rv770_cp_load_microcode(rdev);
1744         if (r)
1745                 return r;
1746         r = r600_cp_resume(rdev);
1747         if (r)
1748                 return r;
1749
1750         r = r600_dma_resume(rdev);
1751         if (r)
1752                 return r;
1753
1754         ring = &rdev->ring[R600_RING_TYPE_UVD_INDEX];
1755         if (ring->ring_size) {
1756                 r = radeon_ring_init(rdev, ring, ring->ring_size, 0,
1757                                      UVD_RBC_RB_RPTR, UVD_RBC_RB_WPTR,
1758                                      RADEON_CP_PACKET2);
1759                 if (!r)
1760                         r = uvd_v1_0_init(rdev);
1761
1762                 if (r)
1763                         DRM_ERROR("radeon: failed initializing UVD (%d).\n", r);
1764         }
1765
1766         r = radeon_ib_pool_init(rdev);
1767         if (r) {
1768                 dev_err(rdev->dev, "IB initialization failed (%d).\n", r);
1769                 return r;
1770         }
1771
1772         r = r600_audio_init(rdev);
1773         if (r) {
1774                 DRM_ERROR("radeon: audio init failed\n");
1775                 return r;
1776         }
1777
1778         return 0;
1779 }
1780
1781 int rv770_resume(struct radeon_device *rdev)
1782 {
1783         int r;
1784
1785         /* Do not reset GPU before posting, on rv770 hw unlike on r500 hw,
1786          * posting will perform necessary task to bring back GPU into good
1787          * shape.
1788          */
1789         /* post card */
1790         atom_asic_init(rdev->mode_info.atom_context);
1791
1792         /* init golden registers */
1793         rv770_init_golden_registers(rdev);
1794
1795         rdev->accel_working = true;
1796         r = rv770_startup(rdev);
1797         if (r) {
1798                 DRM_ERROR("r600 startup failed on resume\n");
1799                 rdev->accel_working = false;
1800                 return r;
1801         }
1802
1803         return r;
1804
1805 }
1806
1807 int rv770_suspend(struct radeon_device *rdev)
1808 {
1809         r600_audio_fini(rdev);
1810         uvd_v1_0_fini(rdev);
1811         radeon_uvd_suspend(rdev);
1812         r700_cp_stop(rdev);
1813         r600_dma_stop(rdev);
1814         r600_irq_suspend(rdev);
1815         radeon_wb_disable(rdev);
1816         rv770_pcie_gart_disable(rdev);
1817
1818         return 0;
1819 }
1820
1821 /* Plan is to move initialization in that function and use
1822  * helper function so that radeon_device_init pretty much
1823  * do nothing more than calling asic specific function. This
1824  * should also allow to remove a bunch of callback function
1825  * like vram_info.
1826  */
1827 int rv770_init(struct radeon_device *rdev)
1828 {
1829         int r;
1830
1831         /* Read BIOS */
1832         if (!radeon_get_bios(rdev)) {
1833                 if (ASIC_IS_AVIVO(rdev))
1834                         return -EINVAL;
1835         }
1836         /* Must be an ATOMBIOS */
1837         if (!rdev->is_atom_bios) {
1838                 dev_err(rdev->dev, "Expecting atombios for R600 GPU\n");
1839                 return -EINVAL;
1840         }
1841         r = radeon_atombios_init(rdev);
1842         if (r)
1843                 return r;
1844         /* Post card if necessary */
1845         if (!radeon_card_posted(rdev)) {
1846                 if (!rdev->bios) {
1847                         dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n");
1848                         return -EINVAL;
1849                 }
1850                 DRM_INFO("GPU not posted. posting now...\n");
1851                 atom_asic_init(rdev->mode_info.atom_context);
1852         }
1853         /* init golden registers */
1854         rv770_init_golden_registers(rdev);
1855         /* Initialize scratch registers */
1856         r600_scratch_init(rdev);
1857         /* Initialize surface registers */
1858         radeon_surface_init(rdev);
1859         /* Initialize clocks */
1860         radeon_get_clock_info(rdev->ddev);
1861         /* Fence driver */
1862         r = radeon_fence_driver_init(rdev);
1863         if (r)
1864                 return r;
1865         /* initialize AGP */
1866         if (rdev->flags & RADEON_IS_AGP) {
1867                 r = radeon_agp_init(rdev);
1868                 if (r)
1869                         radeon_agp_disable(rdev);
1870         }
1871         r = rv770_mc_init(rdev);
1872         if (r)
1873                 return r;
1874         /* Memory manager */
1875         r = radeon_bo_init(rdev);
1876         if (r)
1877                 return r;
1878
1879         rdev->ring[RADEON_RING_TYPE_GFX_INDEX].ring_obj = NULL;
1880         r600_ring_init(rdev, &rdev->ring[RADEON_RING_TYPE_GFX_INDEX], 1024 * 1024);
1881
1882         rdev->ring[R600_RING_TYPE_DMA_INDEX].ring_obj = NULL;
1883         r600_ring_init(rdev, &rdev->ring[R600_RING_TYPE_DMA_INDEX], 64 * 1024);
1884
1885         r = radeon_uvd_init(rdev);
1886         if (!r) {
1887                 rdev->ring[R600_RING_TYPE_UVD_INDEX].ring_obj = NULL;
1888                 r600_ring_init(rdev, &rdev->ring[R600_RING_TYPE_UVD_INDEX],
1889                                4096);
1890         }
1891
1892         rdev->ih.ring_obj = NULL;
1893         r600_ih_ring_init(rdev, 64 * 1024);
1894
1895         r = r600_pcie_gart_init(rdev);
1896         if (r)
1897                 return r;
1898
1899         rdev->accel_working = true;
1900         r = rv770_startup(rdev);
1901         if (r) {
1902                 dev_err(rdev->dev, "disabling GPU acceleration\n");
1903                 r700_cp_fini(rdev);
1904                 r600_dma_fini(rdev);
1905                 r600_irq_fini(rdev);
1906                 radeon_wb_fini(rdev);
1907                 radeon_ib_pool_fini(rdev);
1908                 radeon_irq_kms_fini(rdev);
1909                 rv770_pcie_gart_fini(rdev);
1910                 rdev->accel_working = false;
1911         }
1912
1913         return 0;
1914 }
1915
1916 void rv770_fini(struct radeon_device *rdev)
1917 {
1918         r700_cp_fini(rdev);
1919         r600_dma_fini(rdev);
1920         r600_irq_fini(rdev);
1921         radeon_wb_fini(rdev);
1922         radeon_ib_pool_fini(rdev);
1923         radeon_irq_kms_fini(rdev);
1924         rv770_pcie_gart_fini(rdev);
1925         uvd_v1_0_fini(rdev);
1926         radeon_uvd_fini(rdev);
1927         r600_vram_scratch_fini(rdev);
1928         radeon_gem_fini(rdev);
1929         radeon_fence_driver_fini(rdev);
1930         radeon_agp_fini(rdev);
1931         radeon_bo_fini(rdev);
1932         radeon_atombios_fini(rdev);
1933         kfree(rdev->bios);
1934         rdev->bios = NULL;
1935 }
1936
1937 static void rv770_pcie_gen2_enable(struct radeon_device *rdev)
1938 {
1939         u32 link_width_cntl, lanes, speed_cntl, tmp;
1940         u16 link_cntl2;
1941
1942         if (radeon_pcie_gen2 == 0)
1943                 return;
1944
1945         if (rdev->flags & RADEON_IS_IGP)
1946                 return;
1947
1948         if (!(rdev->flags & RADEON_IS_PCIE))
1949                 return;
1950
1951         /* x2 cards have a special sequence */
1952         if (ASIC_IS_X2(rdev))
1953                 return;
1954
1955         if ((rdev->pdev->bus->max_bus_speed != PCIE_SPEED_5_0GT) &&
1956                 (rdev->pdev->bus->max_bus_speed != PCIE_SPEED_8_0GT))
1957                 return;
1958
1959         DRM_INFO("enabling PCIE gen 2 link speeds, disable with radeon.pcie_gen2=0\n");
1960
1961         /* advertise upconfig capability */
1962         link_width_cntl = RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL);
1963         link_width_cntl &= ~LC_UPCONFIGURE_DIS;
1964         WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl);
1965         link_width_cntl = RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL);
1966         if (link_width_cntl & LC_RENEGOTIATION_SUPPORT) {
1967                 lanes = (link_width_cntl & LC_LINK_WIDTH_RD_MASK) >> LC_LINK_WIDTH_RD_SHIFT;
1968                 link_width_cntl &= ~(LC_LINK_WIDTH_MASK |
1969                                      LC_RECONFIG_ARC_MISSING_ESCAPE);
1970                 link_width_cntl |= lanes | LC_RECONFIG_NOW |
1971                         LC_RENEGOTIATE_EN | LC_UPCONFIGURE_SUPPORT;
1972                 WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl);
1973         } else {
1974                 link_width_cntl |= LC_UPCONFIGURE_DIS;
1975                 WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl);
1976         }
1977
1978         speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
1979         if ((speed_cntl & LC_OTHER_SIDE_EVER_SENT_GEN2) &&
1980             (speed_cntl & LC_OTHER_SIDE_SUPPORTS_GEN2)) {
1981
1982                 tmp = RREG32(0x541c);
1983                 WREG32(0x541c, tmp | 0x8);
1984                 WREG32(MM_CFGREGS_CNTL, MM_WR_TO_CFG_EN);
1985                 link_cntl2 = RREG16(0x4088);
1986                 link_cntl2 &= ~TARGET_LINK_SPEED_MASK;
1987                 link_cntl2 |= 0x2;
1988                 WREG16(0x4088, link_cntl2);
1989                 WREG32(MM_CFGREGS_CNTL, 0);
1990
1991                 speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
1992                 speed_cntl &= ~LC_TARGET_LINK_SPEED_OVERRIDE_EN;
1993                 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
1994
1995                 speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
1996                 speed_cntl |= LC_CLR_FAILED_SPD_CHANGE_CNT;
1997                 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
1998
1999                 speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
2000                 speed_cntl &= ~LC_CLR_FAILED_SPD_CHANGE_CNT;
2001                 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
2002
2003                 speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
2004                 speed_cntl |= LC_GEN2_EN_STRAP;
2005                 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
2006
2007         } else {
2008                 link_width_cntl = RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL);
2009                 /* XXX: only disable it if gen1 bridge vendor == 0x111d or 0x1106 */
2010                 if (1)
2011                         link_width_cntl |= LC_UPCONFIGURE_DIS;
2012                 else
2013                         link_width_cntl &= ~LC_UPCONFIGURE_DIS;
2014                 WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl);
2015         }
2016 }