1/*
   2 * Copyright 2010 Advanced Micro Devices, Inc.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice shall be included in
  12 * all copies or substantial portions of the Software.
  13 *
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 * OTHER DEALINGS IN THE SOFTWARE.
  21 *
  22 * Authors: Alex Deucher
  23 */
  24
  25#include <linux/firmware.h>
  26#include <linux/slab.h>
  27
  28#include <drm/drm_pci.h>
  29#include <drm/drm_vblank.h>
 
  30#include <drm/radeon_drm.h>
  31
  32#include "atom.h"
  33#include "avivod.h"
  34#include "evergreen_blit_shaders.h"
  35#include "evergreen_reg.h"
  36#include "evergreend.h"
  37#include "radeon.h"
  38#include "radeon_asic.h"
  39#include "radeon_audio.h"
  40#include "radeon_ucode.h"
  41
  42#define DC_HPDx_CONTROL(x)        (DC_HPD1_CONTROL     + (x * 0xc))
  43#define DC_HPDx_INT_CONTROL(x)    (DC_HPD1_INT_CONTROL + (x * 0xc))
  44#define DC_HPDx_INT_STATUS_REG(x) (DC_HPD1_INT_STATUS  + (x * 0xc))
  45
  46/*
  47 * Indirect registers accessor
  48 */
  49u32 eg_cg_rreg(struct radeon_device *rdev, u32 reg)
  50{
  51	unsigned long flags;
  52	u32 r;
  53
  54	spin_lock_irqsave(&rdev->cg_idx_lock, flags);
  55	WREG32(EVERGREEN_CG_IND_ADDR, ((reg) & 0xffff));
  56	r = RREG32(EVERGREEN_CG_IND_DATA);
  57	spin_unlock_irqrestore(&rdev->cg_idx_lock, flags);
  58	return r;
  59}
  60
  61void eg_cg_wreg(struct radeon_device *rdev, u32 reg, u32 v)
  62{
  63	unsigned long flags;
  64
  65	spin_lock_irqsave(&rdev->cg_idx_lock, flags);
  66	WREG32(EVERGREEN_CG_IND_ADDR, ((reg) & 0xffff));
  67	WREG32(EVERGREEN_CG_IND_DATA, (v));
  68	spin_unlock_irqrestore(&rdev->cg_idx_lock, flags);
  69}
  70
  71u32 eg_pif_phy0_rreg(struct radeon_device *rdev, u32 reg)
  72{
  73	unsigned long flags;
  74	u32 r;
  75
  76	spin_lock_irqsave(&rdev->pif_idx_lock, flags);
  77	WREG32(EVERGREEN_PIF_PHY0_INDEX, ((reg) & 0xffff));
  78	r = RREG32(EVERGREEN_PIF_PHY0_DATA);
  79	spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
  80	return r;
  81}
  82
  83void eg_pif_phy0_wreg(struct radeon_device *rdev, u32 reg, u32 v)
  84{
  85	unsigned long flags;
  86
  87	spin_lock_irqsave(&rdev->pif_idx_lock, flags);
  88	WREG32(EVERGREEN_PIF_PHY0_INDEX, ((reg) & 0xffff));
  89	WREG32(EVERGREEN_PIF_PHY0_DATA, (v));
  90	spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
  91}
  92
  93u32 eg_pif_phy1_rreg(struct radeon_device *rdev, u32 reg)
  94{
  95	unsigned long flags;
  96	u32 r;
  97
  98	spin_lock_irqsave(&rdev->pif_idx_lock, flags);
  99	WREG32(EVERGREEN_PIF_PHY1_INDEX, ((reg) & 0xffff));
 100	r = RREG32(EVERGREEN_PIF_PHY1_DATA);
 101	spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
 102	return r;
 103}
 104
 105void eg_pif_phy1_wreg(struct radeon_device *rdev, u32 reg, u32 v)
 106{
 107	unsigned long flags;
 108
 109	spin_lock_irqsave(&rdev->pif_idx_lock, flags);
 110	WREG32(EVERGREEN_PIF_PHY1_INDEX, ((reg) & 0xffff));
 111	WREG32(EVERGREEN_PIF_PHY1_DATA, (v));
 112	spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
 113}
 114
 115static const u32 crtc_offsets[6] =
 116{
 117	EVERGREEN_CRTC0_REGISTER_OFFSET,
 118	EVERGREEN_CRTC1_REGISTER_OFFSET,
 119	EVERGREEN_CRTC2_REGISTER_OFFSET,
 120	EVERGREEN_CRTC3_REGISTER_OFFSET,
 121	EVERGREEN_CRTC4_REGISTER_OFFSET,
 122	EVERGREEN_CRTC5_REGISTER_OFFSET
 123};
 124
 125#include "clearstate_evergreen.h"
 126
 127static const u32 sumo_rlc_save_restore_register_list[] =
 128{
 129	0x98fc,
 130	0x9830,
 131	0x9834,
 132	0x9838,
 133	0x9870,
 134	0x9874,
 135	0x8a14,
 136	0x8b24,
 137	0x8bcc,
 138	0x8b10,
 139	0x8d00,
 140	0x8d04,
 141	0x8c00,
 142	0x8c04,
 143	0x8c08,
 144	0x8c0c,
 145	0x8d8c,
 146	0x8c20,
 147	0x8c24,
 148	0x8c28,
 149	0x8c18,
 150	0x8c1c,
 151	0x8cf0,
 152	0x8e2c,
 153	0x8e38,
 154	0x8c30,
 155	0x9508,
 156	0x9688,
 157	0x9608,
 158	0x960c,
 159	0x9610,
 160	0x9614,
 161	0x88c4,
 162	0x88d4,
 163	0xa008,
 164	0x900c,
 165	0x9100,
 166	0x913c,
 167	0x98f8,
 168	0x98f4,
 169	0x9b7c,
 170	0x3f8c,
 171	0x8950,
 172	0x8954,
 173	0x8a18,
 174	0x8b28,
 175	0x9144,
 176	0x9148,
 177	0x914c,
 178	0x3f90,
 179	0x3f94,
 180	0x915c,
 181	0x9160,
 182	0x9178,
 183	0x917c,
 184	0x9180,
 185	0x918c,
 186	0x9190,
 187	0x9194,
 188	0x9198,
 189	0x919c,
 190	0x91a8,
 191	0x91ac,
 192	0x91b0,
 193	0x91b4,
 194	0x91b8,
 195	0x91c4,
 196	0x91c8,
 197	0x91cc,
 198	0x91d0,
 199	0x91d4,
 200	0x91e0,
 201	0x91e4,
 202	0x91ec,
 203	0x91f0,
 204	0x91f4,
 205	0x9200,
 206	0x9204,
 207	0x929c,
 208	0x9150,
 209	0x802c,
 210};
 211
 212static void evergreen_gpu_init(struct radeon_device *rdev);
 213void evergreen_fini(struct radeon_device *rdev);
 214void evergreen_pcie_gen2_enable(struct radeon_device *rdev);
 215void evergreen_program_aspm(struct radeon_device *rdev);
 216extern void cayman_cp_int_cntl_setup(struct radeon_device *rdev,
 217				     int ring, u32 cp_int_cntl);
 218extern void cayman_vm_decode_fault(struct radeon_device *rdev,
 219				   u32 status, u32 addr);
 220void cik_init_cp_pg_table(struct radeon_device *rdev);
 221
 222extern u32 si_get_csb_size(struct radeon_device *rdev);
 223extern void si_get_csb_buffer(struct radeon_device *rdev, volatile u32 *buffer);
 224extern u32 cik_get_csb_size(struct radeon_device *rdev);
 225extern void cik_get_csb_buffer(struct radeon_device *rdev, volatile u32 *buffer);
 226extern void rv770_set_clk_bypass_mode(struct radeon_device *rdev);
 227
 228static const u32 evergreen_golden_registers[] =
 229{
 230	0x3f90, 0xffff0000, 0xff000000,
 231	0x9148, 0xffff0000, 0xff000000,
 232	0x3f94, 0xffff0000, 0xff000000,
 233	0x914c, 0xffff0000, 0xff000000,
 234	0x9b7c, 0xffffffff, 0x00000000,
 235	0x8a14, 0xffffffff, 0x00000007,
 236	0x8b10, 0xffffffff, 0x00000000,
 237	0x960c, 0xffffffff, 0x54763210,
 238	0x88c4, 0xffffffff, 0x000000c2,
 239	0x88d4, 0xffffffff, 0x00000010,
 240	0x8974, 0xffffffff, 0x00000000,
 241	0xc78, 0x00000080, 0x00000080,
 242	0x5eb4, 0xffffffff, 0x00000002,
 243	0x5e78, 0xffffffff, 0x001000f0,
 244	0x6104, 0x01000300, 0x00000000,
 245	0x5bc0, 0x00300000, 0x00000000,
 246	0x7030, 0xffffffff, 0x00000011,
 247	0x7c30, 0xffffffff, 0x00000011,
 248	0x10830, 0xffffffff, 0x00000011,
 249	0x11430, 0xffffffff, 0x00000011,
 250	0x12030, 0xffffffff, 0x00000011,
 251	0x12c30, 0xffffffff, 0x00000011,
 252	0xd02c, 0xffffffff, 0x08421000,
 253	0x240c, 0xffffffff, 0x00000380,
 254	0x8b24, 0xffffffff, 0x00ff0fff,
 255	0x28a4c, 0x06000000, 0x06000000,
 256	0x10c, 0x00000001, 0x00000001,
 257	0x8d00, 0xffffffff, 0x100e4848,
 258	0x8d04, 0xffffffff, 0x00164745,
 259	0x8c00, 0xffffffff, 0xe4000003,
 260	0x8c04, 0xffffffff, 0x40600060,
 261	0x8c08, 0xffffffff, 0x001c001c,
 262	0x8cf0, 0xffffffff, 0x08e00620,
 263	0x8c20, 0xffffffff, 0x00800080,
 264	0x8c24, 0xffffffff, 0x00800080,
 265	0x8c18, 0xffffffff, 0x20202078,
 266	0x8c1c, 0xffffffff, 0x00001010,
 267	0x28350, 0xffffffff, 0x00000000,
 268	0xa008, 0xffffffff, 0x00010000,
 269	0x5c4, 0xffffffff, 0x00000001,
 270	0x9508, 0xffffffff, 0x00000002,
 271	0x913c, 0x0000000f, 0x0000000a
 272};
 273
 274static const u32 evergreen_golden_registers2[] =
 275{
 276	0x2f4c, 0xffffffff, 0x00000000,
 277	0x54f4, 0xffffffff, 0x00000000,
 278	0x54f0, 0xffffffff, 0x00000000,
 279	0x5498, 0xffffffff, 0x00000000,
 280	0x549c, 0xffffffff, 0x00000000,
 281	0x5494, 0xffffffff, 0x00000000,
 282	0x53cc, 0xffffffff, 0x00000000,
 283	0x53c8, 0xffffffff, 0x00000000,
 284	0x53c4, 0xffffffff, 0x00000000,
 285	0x53c0, 0xffffffff, 0x00000000,
 286	0x53bc, 0xffffffff, 0x00000000,
 287	0x53b8, 0xffffffff, 0x00000000,
 288	0x53b4, 0xffffffff, 0x00000000,
 289	0x53b0, 0xffffffff, 0x00000000
 290};
 291
 292static const u32 cypress_mgcg_init[] =
 293{
 294	0x802c, 0xffffffff, 0xc0000000,
 295	0x5448, 0xffffffff, 0x00000100,
 296	0x55e4, 0xffffffff, 0x00000100,
 297	0x160c, 0xffffffff, 0x00000100,
 298	0x5644, 0xffffffff, 0x00000100,
 299	0xc164, 0xffffffff, 0x00000100,
 300	0x8a18, 0xffffffff, 0x00000100,
 301	0x897c, 0xffffffff, 0x06000100,
 302	0x8b28, 0xffffffff, 0x00000100,
 303	0x9144, 0xffffffff, 0x00000100,
 304	0x9a60, 0xffffffff, 0x00000100,
 305	0x9868, 0xffffffff, 0x00000100,
 306	0x8d58, 0xffffffff, 0x00000100,
 307	0x9510, 0xffffffff, 0x00000100,
 308	0x949c, 0xffffffff, 0x00000100,
 309	0x9654, 0xffffffff, 0x00000100,
 310	0x9030, 0xffffffff, 0x00000100,
 311	0x9034, 0xffffffff, 0x00000100,
 312	0x9038, 0xffffffff, 0x00000100,
 313	0x903c, 0xffffffff, 0x00000100,
 314	0x9040, 0xffffffff, 0x00000100,
 315	0xa200, 0xffffffff, 0x00000100,
 316	0xa204, 0xffffffff, 0x00000100,
 317	0xa208, 0xffffffff, 0x00000100,
 318	0xa20c, 0xffffffff, 0x00000100,
 319	0x971c, 0xffffffff, 0x00000100,
 320	0x977c, 0xffffffff, 0x00000100,
 321	0x3f80, 0xffffffff, 0x00000100,
 322	0xa210, 0xffffffff, 0x00000100,
 323	0xa214, 0xffffffff, 0x00000100,
 324	0x4d8, 0xffffffff, 0x00000100,
 325	0x9784, 0xffffffff, 0x00000100,
 326	0x9698, 0xffffffff, 0x00000100,
 327	0x4d4, 0xffffffff, 0x00000200,
 328	0x30cc, 0xffffffff, 0x00000100,
 329	0xd0c0, 0xffffffff, 0xff000100,
 330	0x802c, 0xffffffff, 0x40000000,
 331	0x915c, 0xffffffff, 0x00010000,
 332	0x9160, 0xffffffff, 0x00030002,
 333	0x9178, 0xffffffff, 0x00070000,
 334	0x917c, 0xffffffff, 0x00030002,
 335	0x9180, 0xffffffff, 0x00050004,
 336	0x918c, 0xffffffff, 0x00010006,
 337	0x9190, 0xffffffff, 0x00090008,
 338	0x9194, 0xffffffff, 0x00070000,
 339	0x9198, 0xffffffff, 0x00030002,
 340	0x919c, 0xffffffff, 0x00050004,
 341	0x91a8, 0xffffffff, 0x00010006,
 342	0x91ac, 0xffffffff, 0x00090008,
 343	0x91b0, 0xffffffff, 0x00070000,
 344	0x91b4, 0xffffffff, 0x00030002,
 345	0x91b8, 0xffffffff, 0x00050004,
 346	0x91c4, 0xffffffff, 0x00010006,
 347	0x91c8, 0xffffffff, 0x00090008,
 348	0x91cc, 0xffffffff, 0x00070000,
 349	0x91d0, 0xffffffff, 0x00030002,
 350	0x91d4, 0xffffffff, 0x00050004,
 351	0x91e0, 0xffffffff, 0x00010006,
 352	0x91e4, 0xffffffff, 0x00090008,
 353	0x91e8, 0xffffffff, 0x00000000,
 354	0x91ec, 0xffffffff, 0x00070000,
 355	0x91f0, 0xffffffff, 0x00030002,
 356	0x91f4, 0xffffffff, 0x00050004,
 357	0x9200, 0xffffffff, 0x00010006,
 358	0x9204, 0xffffffff, 0x00090008,
 359	0x9208, 0xffffffff, 0x00070000,
 360	0x920c, 0xffffffff, 0x00030002,
 361	0x9210, 0xffffffff, 0x00050004,
 362	0x921c, 0xffffffff, 0x00010006,
 363	0x9220, 0xffffffff, 0x00090008,
 364	0x9224, 0xffffffff, 0x00070000,
 365	0x9228, 0xffffffff, 0x00030002,
 366	0x922c, 0xffffffff, 0x00050004,
 367	0x9238, 0xffffffff, 0x00010006,
 368	0x923c, 0xffffffff, 0x00090008,
 369	0x9240, 0xffffffff, 0x00070000,
 370	0x9244, 0xffffffff, 0x00030002,
 371	0x9248, 0xffffffff, 0x00050004,
 372	0x9254, 0xffffffff, 0x00010006,
 373	0x9258, 0xffffffff, 0x00090008,
 374	0x925c, 0xffffffff, 0x00070000,
 375	0x9260, 0xffffffff, 0x00030002,
 376	0x9264, 0xffffffff, 0x00050004,
 377	0x9270, 0xffffffff, 0x00010006,
 378	0x9274, 0xffffffff, 0x00090008,
 379	0x9278, 0xffffffff, 0x00070000,
 380	0x927c, 0xffffffff, 0x00030002,
 381	0x9280, 0xffffffff, 0x00050004,
 382	0x928c, 0xffffffff, 0x00010006,
 383	0x9290, 0xffffffff, 0x00090008,
 384	0x9294, 0xffffffff, 0x00000000,
 385	0x929c, 0xffffffff, 0x00000001,
 386	0x802c, 0xffffffff, 0x40010000,
 387	0x915c, 0xffffffff, 0x00010000,
 388	0x9160, 0xffffffff, 0x00030002,
 389	0x9178, 0xffffffff, 0x00070000,
 390	0x917c, 0xffffffff, 0x00030002,
 391	0x9180, 0xffffffff, 0x00050004,
 392	0x918c, 0xffffffff, 0x00010006,
 393	0x9190, 0xffffffff, 0x00090008,
 394	0x9194, 0xffffffff, 0x00070000,
 395	0x9198, 0xffffffff, 0x00030002,
 396	0x919c, 0xffffffff, 0x00050004,
 397	0x91a8, 0xffffffff, 0x00010006,
 398	0x91ac, 0xffffffff, 0x00090008,
 399	0x91b0, 0xffffffff, 0x00070000,
 400	0x91b4, 0xffffffff, 0x00030002,
 401	0x91b8, 0xffffffff, 0x00050004,
 402	0x91c4, 0xffffffff, 0x00010006,
 403	0x91c8, 0xffffffff, 0x00090008,
 404	0x91cc, 0xffffffff, 0x00070000,
 405	0x91d0, 0xffffffff, 0x00030002,
 406	0x91d4, 0xffffffff, 0x00050004,
 407	0x91e0, 0xffffffff, 0x00010006,
 408	0x91e4, 0xffffffff, 0x00090008,
 409	0x91e8, 0xffffffff, 0x00000000,
 410	0x91ec, 0xffffffff, 0x00070000,
 411	0x91f0, 0xffffffff, 0x00030002,
 412	0x91f4, 0xffffffff, 0x00050004,
 413	0x9200, 0xffffffff, 0x00010006,
 414	0x9204, 0xffffffff, 0x00090008,
 415	0x9208, 0xffffffff, 0x00070000,
 416	0x920c, 0xffffffff, 0x00030002,
 417	0x9210, 0xffffffff, 0x00050004,
 418	0x921c, 0xffffffff, 0x00010006,
 419	0x9220, 0xffffffff, 0x00090008,
 420	0x9224, 0xffffffff, 0x00070000,
 421	0x9228, 0xffffffff, 0x00030002,
 422	0x922c, 0xffffffff, 0x00050004,
 423	0x9238, 0xffffffff, 0x00010006,
 424	0x923c, 0xffffffff, 0x00090008,
 425	0x9240, 0xffffffff, 0x00070000,
 426	0x9244, 0xffffffff, 0x00030002,
 427	0x9248, 0xffffffff, 0x00050004,
 428	0x9254, 0xffffffff, 0x00010006,
 429	0x9258, 0xffffffff, 0x00090008,
 430	0x925c, 0xffffffff, 0x00070000,
 431	0x9260, 0xffffffff, 0x00030002,
 432	0x9264, 0xffffffff, 0x00050004,
 433	0x9270, 0xffffffff, 0x00010006,
 434	0x9274, 0xffffffff, 0x00090008,
 435	0x9278, 0xffffffff, 0x00070000,
 436	0x927c, 0xffffffff, 0x00030002,
 437	0x9280, 0xffffffff, 0x00050004,
 438	0x928c, 0xffffffff, 0x00010006,
 439	0x9290, 0xffffffff, 0x00090008,
 440	0x9294, 0xffffffff, 0x00000000,
 441	0x929c, 0xffffffff, 0x00000001,
 442	0x802c, 0xffffffff, 0xc0000000
 443};
 444
 445static const u32 redwood_mgcg_init[] =
 446{
 447	0x802c, 0xffffffff, 0xc0000000,
 448	0x5448, 0xffffffff, 0x00000100,
 449	0x55e4, 0xffffffff, 0x00000100,
 450	0x160c, 0xffffffff, 0x00000100,
 451	0x5644, 0xffffffff, 0x00000100,
 452	0xc164, 0xffffffff, 0x00000100,
 453	0x8a18, 0xffffffff, 0x00000100,
 454	0x897c, 0xffffffff, 0x06000100,
 455	0x8b28, 0xffffffff, 0x00000100,
 456	0x9144, 0xffffffff, 0x00000100,
 457	0x9a60, 0xffffffff, 0x00000100,
 458	0x9868, 0xffffffff, 0x00000100,
 459	0x8d58, 0xffffffff, 0x00000100,
 460	0x9510, 0xffffffff, 0x00000100,
 461	0x949c, 0xffffffff, 0x00000100,
 462	0x9654, 0xffffffff, 0x00000100,
 463	0x9030, 0xffffffff, 0x00000100,
 464	0x9034, 0xffffffff, 0x00000100,
 465	0x9038, 0xffffffff, 0x00000100,
 466	0x903c, 0xffffffff, 0x00000100,
 467	0x9040, 0xffffffff, 0x00000100,
 468	0xa200, 0xffffffff, 0x00000100,
 469	0xa204, 0xffffffff, 0x00000100,
 470	0xa208, 0xffffffff, 0x00000100,
 471	0xa20c, 0xffffffff, 0x00000100,
 472	0x971c, 0xffffffff, 0x00000100,
 473	0x977c, 0xffffffff, 0x00000100,
 474	0x3f80, 0xffffffff, 0x00000100,
 475	0xa210, 0xffffffff, 0x00000100,
 476	0xa214, 0xffffffff, 0x00000100,
 477	0x4d8, 0xffffffff, 0x00000100,
 478	0x9784, 0xffffffff, 0x00000100,
 479	0x9698, 0xffffffff, 0x00000100,
 480	0x4d4, 0xffffffff, 0x00000200,
 481	0x30cc, 0xffffffff, 0x00000100,
 482	0xd0c0, 0xffffffff, 0xff000100,
 483	0x802c, 0xffffffff, 0x40000000,
 484	0x915c, 0xffffffff, 0x00010000,
 485	0x9160, 0xffffffff, 0x00030002,
 486	0x9178, 0xffffffff, 0x00070000,
 487	0x917c, 0xffffffff, 0x00030002,
 488	0x9180, 0xffffffff, 0x00050004,
 489	0x918c, 0xffffffff, 0x00010006,
 490	0x9190, 0xffffffff, 0x00090008,
 491	0x9194, 0xffffffff, 0x00070000,
 492	0x9198, 0xffffffff, 0x00030002,
 493	0x919c, 0xffffffff, 0x00050004,
 494	0x91a8, 0xffffffff, 0x00010006,
 495	0x91ac, 0xffffffff, 0x00090008,
 496	0x91b0, 0xffffffff, 0x00070000,
 497	0x91b4, 0xffffffff, 0x00030002,
 498	0x91b8, 0xffffffff, 0x00050004,
 499	0x91c4, 0xffffffff, 0x00010006,
 500	0x91c8, 0xffffffff, 0x00090008,
 501	0x91cc, 0xffffffff, 0x00070000,
 502	0x91d0, 0xffffffff, 0x00030002,
 503	0x91d4, 0xffffffff, 0x00050004,
 504	0x91e0, 0xffffffff, 0x00010006,
 505	0x91e4, 0xffffffff, 0x00090008,
 506	0x91e8, 0xffffffff, 0x00000000,
 507	0x91ec, 0xffffffff, 0x00070000,
 508	0x91f0, 0xffffffff, 0x00030002,
 509	0x91f4, 0xffffffff, 0x00050004,
 510	0x9200, 0xffffffff, 0x00010006,
 511	0x9204, 0xffffffff, 0x00090008,
 512	0x9294, 0xffffffff, 0x00000000,
 513	0x929c, 0xffffffff, 0x00000001,
 514	0x802c, 0xffffffff, 0xc0000000
 515};
 516
 517static const u32 cedar_golden_registers[] =
 518{
 519	0x3f90, 0xffff0000, 0xff000000,
 520	0x9148, 0xffff0000, 0xff000000,
 521	0x3f94, 0xffff0000, 0xff000000,
 522	0x914c, 0xffff0000, 0xff000000,
 523	0x9b7c, 0xffffffff, 0x00000000,
 524	0x8a14, 0xffffffff, 0x00000007,
 525	0x8b10, 0xffffffff, 0x00000000,
 526	0x960c, 0xffffffff, 0x54763210,
 527	0x88c4, 0xffffffff, 0x000000c2,
 528	0x88d4, 0xffffffff, 0x00000000,
 529	0x8974, 0xffffffff, 0x00000000,
 530	0xc78, 0x00000080, 0x00000080,
 531	0x5eb4, 0xffffffff, 0x00000002,
 532	0x5e78, 0xffffffff, 0x001000f0,
 533	0x6104, 0x01000300, 0x00000000,
 534	0x5bc0, 0x00300000, 0x00000000,
 535	0x7030, 0xffffffff, 0x00000011,
 536	0x7c30, 0xffffffff, 0x00000011,
 537	0x10830, 0xffffffff, 0x00000011,
 538	0x11430, 0xffffffff, 0x00000011,
 539	0xd02c, 0xffffffff, 0x08421000,
 540	0x240c, 0xffffffff, 0x00000380,
 541	0x8b24, 0xffffffff, 0x00ff0fff,
 542	0x28a4c, 0x06000000, 0x06000000,
 543	0x10c, 0x00000001, 0x00000001,
 544	0x8d00, 0xffffffff, 0x100e4848,
 545	0x8d04, 0xffffffff, 0x00164745,
 546	0x8c00, 0xffffffff, 0xe4000003,
 547	0x8c04, 0xffffffff, 0x40600060,
 548	0x8c08, 0xffffffff, 0x001c001c,
 549	0x8cf0, 0xffffffff, 0x08e00410,
 550	0x8c20, 0xffffffff, 0x00800080,
 551	0x8c24, 0xffffffff, 0x00800080,
 552	0x8c18, 0xffffffff, 0x20202078,
 553	0x8c1c, 0xffffffff, 0x00001010,
 554	0x28350, 0xffffffff, 0x00000000,
 555	0xa008, 0xffffffff, 0x00010000,
 556	0x5c4, 0xffffffff, 0x00000001,
 557	0x9508, 0xffffffff, 0x00000002
 558};
 559
 560static const u32 cedar_mgcg_init[] =
 561{
 562	0x802c, 0xffffffff, 0xc0000000,
 563	0x5448, 0xffffffff, 0x00000100,
 564	0x55e4, 0xffffffff, 0x00000100,
 565	0x160c, 0xffffffff, 0x00000100,
 566	0x5644, 0xffffffff, 0x00000100,
 567	0xc164, 0xffffffff, 0x00000100,
 568	0x8a18, 0xffffffff, 0x00000100,
 569	0x897c, 0xffffffff, 0x06000100,
 570	0x8b28, 0xffffffff, 0x00000100,
 571	0x9144, 0xffffffff, 0x00000100,
 572	0x9a60, 0xffffffff, 0x00000100,
 573	0x9868, 0xffffffff, 0x00000100,
 574	0x8d58, 0xffffffff, 0x00000100,
 575	0x9510, 0xffffffff, 0x00000100,
 576	0x949c, 0xffffffff, 0x00000100,
 577	0x9654, 0xffffffff, 0x00000100,
 578	0x9030, 0xffffffff, 0x00000100,
 579	0x9034, 0xffffffff, 0x00000100,
 580	0x9038, 0xffffffff, 0x00000100,
 581	0x903c, 0xffffffff, 0x00000100,
 582	0x9040, 0xffffffff, 0x00000100,
 583	0xa200, 0xffffffff, 0x00000100,
 584	0xa204, 0xffffffff, 0x00000100,
 585	0xa208, 0xffffffff, 0x00000100,
 586	0xa20c, 0xffffffff, 0x00000100,
 587	0x971c, 0xffffffff, 0x00000100,
 588	0x977c, 0xffffffff, 0x00000100,
 589	0x3f80, 0xffffffff, 0x00000100,
 590	0xa210, 0xffffffff, 0x00000100,
 591	0xa214, 0xffffffff, 0x00000100,
 592	0x4d8, 0xffffffff, 0x00000100,
 593	0x9784, 0xffffffff, 0x00000100,
 594	0x9698, 0xffffffff, 0x00000100,
 595	0x4d4, 0xffffffff, 0x00000200,
 596	0x30cc, 0xffffffff, 0x00000100,
 597	0xd0c0, 0xffffffff, 0xff000100,
 598	0x802c, 0xffffffff, 0x40000000,
 599	0x915c, 0xffffffff, 0x00010000,
 600	0x9178, 0xffffffff, 0x00050000,
 601	0x917c, 0xffffffff, 0x00030002,
 602	0x918c, 0xffffffff, 0x00010004,
 603	0x9190, 0xffffffff, 0x00070006,
 604	0x9194, 0xffffffff, 0x00050000,
 605	0x9198, 0xffffffff, 0x00030002,
 606	0x91a8, 0xffffffff, 0x00010004,
 607	0x91ac, 0xffffffff, 0x00070006,
 608	0x91e8, 0xffffffff, 0x00000000,
 609	0x9294, 0xffffffff, 0x00000000,
 610	0x929c, 0xffffffff, 0x00000001,
 611	0x802c, 0xffffffff, 0xc0000000
 612};
 613
 614static const u32 juniper_mgcg_init[] =
 615{
 616	0x802c, 0xffffffff, 0xc0000000,
 617	0x5448, 0xffffffff, 0x00000100,
 618	0x55e4, 0xffffffff, 0x00000100,
 619	0x160c, 0xffffffff, 0x00000100,
 620	0x5644, 0xffffffff, 0x00000100,
 621	0xc164, 0xffffffff, 0x00000100,
 622	0x8a18, 0xffffffff, 0x00000100,
 623	0x897c, 0xffffffff, 0x06000100,
 624	0x8b28, 0xffffffff, 0x00000100,
 625	0x9144, 0xffffffff, 0x00000100,
 626	0x9a60, 0xffffffff, 0x00000100,
 627	0x9868, 0xffffffff, 0x00000100,
 628	0x8d58, 0xffffffff, 0x00000100,
 629	0x9510, 0xffffffff, 0x00000100,
 630	0x949c, 0xffffffff, 0x00000100,
 631	0x9654, 0xffffffff, 0x00000100,
 632	0x9030, 0xffffffff, 0x00000100,
 633	0x9034, 0xffffffff, 0x00000100,
 634	0x9038, 0xffffffff, 0x00000100,
 635	0x903c, 0xffffffff, 0x00000100,
 636	0x9040, 0xffffffff, 0x00000100,
 637	0xa200, 0xffffffff, 0x00000100,
 638	0xa204, 0xffffffff, 0x00000100,
 639	0xa208, 0xffffffff, 0x00000100,
 640	0xa20c, 0xffffffff, 0x00000100,
 641	0x971c, 0xffffffff, 0x00000100,
 642	0xd0c0, 0xffffffff, 0xff000100,
 643	0x802c, 0xffffffff, 0x40000000,
 644	0x915c, 0xffffffff, 0x00010000,
 645	0x9160, 0xffffffff, 0x00030002,
 646	0x9178, 0xffffffff, 0x00070000,
 647	0x917c, 0xffffffff, 0x00030002,
 648	0x9180, 0xffffffff, 0x00050004,
 649	0x918c, 0xffffffff, 0x00010006,
 650	0x9190, 0xffffffff, 0x00090008,
 651	0x9194, 0xffffffff, 0x00070000,
 652	0x9198, 0xffffffff, 0x00030002,
 653	0x919c, 0xffffffff, 0x00050004,
 654	0x91a8, 0xffffffff, 0x00010006,
 655	0x91ac, 0xffffffff, 0x00090008,
 656	0x91b0, 0xffffffff, 0x00070000,
 657	0x91b4, 0xffffffff, 0x00030002,
 658	0x91b8, 0xffffffff, 0x00050004,
 659	0x91c4, 0xffffffff, 0x00010006,
 660	0x91c8, 0xffffffff, 0x00090008,
 661	0x91cc, 0xffffffff, 0x00070000,
 662	0x91d0, 0xffffffff, 0x00030002,
 663	0x91d4, 0xffffffff, 0x00050004,
 664	0x91e0, 0xffffffff, 0x00010006,
 665	0x91e4, 0xffffffff, 0x00090008,
 666	0x91e8, 0xffffffff, 0x00000000,
 667	0x91ec, 0xffffffff, 0x00070000,
 668	0x91f0, 0xffffffff, 0x00030002,
 669	0x91f4, 0xffffffff, 0x00050004,
 670	0x9200, 0xffffffff, 0x00010006,
 671	0x9204, 0xffffffff, 0x00090008,
 672	0x9208, 0xffffffff, 0x00070000,
 673	0x920c, 0xffffffff, 0x00030002,
 674	0x9210, 0xffffffff, 0x00050004,
 675	0x921c, 0xffffffff, 0x00010006,
 676	0x9220, 0xffffffff, 0x00090008,
 677	0x9224, 0xffffffff, 0x00070000,
 678	0x9228, 0xffffffff, 0x00030002,
 679	0x922c, 0xffffffff, 0x00050004,
 680	0x9238, 0xffffffff, 0x00010006,
 681	0x923c, 0xffffffff, 0x00090008,
 682	0x9240, 0xffffffff, 0x00070000,
 683	0x9244, 0xffffffff, 0x00030002,
 684	0x9248, 0xffffffff, 0x00050004,
 685	0x9254, 0xffffffff, 0x00010006,
 686	0x9258, 0xffffffff, 0x00090008,
 687	0x925c, 0xffffffff, 0x00070000,
 688	0x9260, 0xffffffff, 0x00030002,
 689	0x9264, 0xffffffff, 0x00050004,
 690	0x9270, 0xffffffff, 0x00010006,
 691	0x9274, 0xffffffff, 0x00090008,
 692	0x9278, 0xffffffff, 0x00070000,
 693	0x927c, 0xffffffff, 0x00030002,
 694	0x9280, 0xffffffff, 0x00050004,
 695	0x928c, 0xffffffff, 0x00010006,
 696	0x9290, 0xffffffff, 0x00090008,
 697	0x9294, 0xffffffff, 0x00000000,
 698	0x929c, 0xffffffff, 0x00000001,
 699	0x802c, 0xffffffff, 0xc0000000,
 700	0x977c, 0xffffffff, 0x00000100,
 701	0x3f80, 0xffffffff, 0x00000100,
 702	0xa210, 0xffffffff, 0x00000100,
 703	0xa214, 0xffffffff, 0x00000100,
 704	0x4d8, 0xffffffff, 0x00000100,
 705	0x9784, 0xffffffff, 0x00000100,
 706	0x9698, 0xffffffff, 0x00000100,
 707	0x4d4, 0xffffffff, 0x00000200,
 708	0x30cc, 0xffffffff, 0x00000100,
 709	0x802c, 0xffffffff, 0xc0000000
 710};
 711
 712static const u32 supersumo_golden_registers[] =
 713{
 714	0x5eb4, 0xffffffff, 0x00000002,
 715	0x5c4, 0xffffffff, 0x00000001,
 716	0x7030, 0xffffffff, 0x00000011,
 717	0x7c30, 0xffffffff, 0x00000011,
 718	0x6104, 0x01000300, 0x00000000,
 719	0x5bc0, 0x00300000, 0x00000000,
 720	0x8c04, 0xffffffff, 0x40600060,
 721	0x8c08, 0xffffffff, 0x001c001c,
 722	0x8c20, 0xffffffff, 0x00800080,
 723	0x8c24, 0xffffffff, 0x00800080,
 724	0x8c18, 0xffffffff, 0x20202078,
 725	0x8c1c, 0xffffffff, 0x00001010,
 726	0x918c, 0xffffffff, 0x00010006,
 727	0x91a8, 0xffffffff, 0x00010006,
 728	0x91c4, 0xffffffff, 0x00010006,
 729	0x91e0, 0xffffffff, 0x00010006,
 730	0x9200, 0xffffffff, 0x00010006,
 731	0x9150, 0xffffffff, 0x6e944040,
 732	0x917c, 0xffffffff, 0x00030002,
 733	0x9180, 0xffffffff, 0x00050004,
 734	0x9198, 0xffffffff, 0x00030002,
 735	0x919c, 0xffffffff, 0x00050004,
 736	0x91b4, 0xffffffff, 0x00030002,
 737	0x91b8, 0xffffffff, 0x00050004,
 738	0x91d0, 0xffffffff, 0x00030002,
 739	0x91d4, 0xffffffff, 0x00050004,
 740	0x91f0, 0xffffffff, 0x00030002,
 741	0x91f4, 0xffffffff, 0x00050004,
 742	0x915c, 0xffffffff, 0x00010000,
 743	0x9160, 0xffffffff, 0x00030002,
 744	0x3f90, 0xffff0000, 0xff000000,
 745	0x9178, 0xffffffff, 0x00070000,
 746	0x9194, 0xffffffff, 0x00070000,
 747	0x91b0, 0xffffffff, 0x00070000,
 748	0x91cc, 0xffffffff, 0x00070000,
 749	0x91ec, 0xffffffff, 0x00070000,
 750	0x9148, 0xffff0000, 0xff000000,
 751	0x9190, 0xffffffff, 0x00090008,
 752	0x91ac, 0xffffffff, 0x00090008,
 753	0x91c8, 0xffffffff, 0x00090008,
 754	0x91e4, 0xffffffff, 0x00090008,
 755	0x9204, 0xffffffff, 0x00090008,
 756	0x3f94, 0xffff0000, 0xff000000,
 757	0x914c, 0xffff0000, 0xff000000,
 758	0x929c, 0xffffffff, 0x00000001,
 759	0x8a18, 0xffffffff, 0x00000100,
 760	0x8b28, 0xffffffff, 0x00000100,
 761	0x9144, 0xffffffff, 0x00000100,
 762	0x5644, 0xffffffff, 0x00000100,
 763	0x9b7c, 0xffffffff, 0x00000000,
 764	0x8030, 0xffffffff, 0x0000100a,
 765	0x8a14, 0xffffffff, 0x00000007,
 766	0x8b24, 0xffffffff, 0x00ff0fff,
 767	0x8b10, 0xffffffff, 0x00000000,
 768	0x28a4c, 0x06000000, 0x06000000,
 769	0x4d8, 0xffffffff, 0x00000100,
 770	0x913c, 0xffff000f, 0x0100000a,
 771	0x960c, 0xffffffff, 0x54763210,
 772	0x88c4, 0xffffffff, 0x000000c2,
 773	0x88d4, 0xffffffff, 0x00000010,
 774	0x8974, 0xffffffff, 0x00000000,
 775	0xc78, 0x00000080, 0x00000080,
 776	0x5e78, 0xffffffff, 0x001000f0,
 777	0xd02c, 0xffffffff, 0x08421000,
 778	0xa008, 0xffffffff, 0x00010000,
 779	0x8d00, 0xffffffff, 0x100e4848,
 780	0x8d04, 0xffffffff, 0x00164745,
 781	0x8c00, 0xffffffff, 0xe4000003,
 782	0x8cf0, 0x1fffffff, 0x08e00620,
 783	0x28350, 0xffffffff, 0x00000000,
 784	0x9508, 0xffffffff, 0x00000002
 785};
 786
 787static const u32 sumo_golden_registers[] =
 788{
 789	0x900c, 0x00ffffff, 0x0017071f,
 790	0x8c18, 0xffffffff, 0x10101060,
 791	0x8c1c, 0xffffffff, 0x00001010,
 792	0x8c30, 0x0000000f, 0x00000005,
 793	0x9688, 0x0000000f, 0x00000007
 794};
 795
 796static const u32 wrestler_golden_registers[] =
 797{
 798	0x5eb4, 0xffffffff, 0x00000002,
 799	0x5c4, 0xffffffff, 0x00000001,
 800	0x7030, 0xffffffff, 0x00000011,
 801	0x7c30, 0xffffffff, 0x00000011,
 802	0x6104, 0x01000300, 0x00000000,
 803	0x5bc0, 0x00300000, 0x00000000,
 804	0x918c, 0xffffffff, 0x00010006,
 805	0x91a8, 0xffffffff, 0x00010006,
 806	0x9150, 0xffffffff, 0x6e944040,
 807	0x917c, 0xffffffff, 0x00030002,
 808	0x9198, 0xffffffff, 0x00030002,
 809	0x915c, 0xffffffff, 0x00010000,
 810	0x3f90, 0xffff0000, 0xff000000,
 811	0x9178, 0xffffffff, 0x00070000,
 812	0x9194, 0xffffffff, 0x00070000,
 813	0x9148, 0xffff0000, 0xff000000,
 814	0x9190, 0xffffffff, 0x00090008,
 815	0x91ac, 0xffffffff, 0x00090008,
 816	0x3f94, 0xffff0000, 0xff000000,
 817	0x914c, 0xffff0000, 0xff000000,
 818	0x929c, 0xffffffff, 0x00000001,
 819	0x8a18, 0xffffffff, 0x00000100,
 820	0x8b28, 0xffffffff, 0x00000100,
 821	0x9144, 0xffffffff, 0x00000100,
 822	0x9b7c, 0xffffffff, 0x00000000,
 823	0x8030, 0xffffffff, 0x0000100a,
 824	0x8a14, 0xffffffff, 0x00000001,
 825	0x8b24, 0xffffffff, 0x00ff0fff,
 826	0x8b10, 0xffffffff, 0x00000000,
 827	0x28a4c, 0x06000000, 0x06000000,
 828	0x4d8, 0xffffffff, 0x00000100,
 829	0x913c, 0xffff000f, 0x0100000a,
 830	0x960c, 0xffffffff, 0x54763210,
 831	0x88c4, 0xffffffff, 0x000000c2,
 832	0x88d4, 0xffffffff, 0x00000010,
 833	0x8974, 0xffffffff, 0x00000000,
 834	0xc78, 0x00000080, 0x00000080,
 835	0x5e78, 0xffffffff, 0x001000f0,
 836	0xd02c, 0xffffffff, 0x08421000,
 837	0xa008, 0xffffffff, 0x00010000,
 838	0x8d00, 0xffffffff, 0x100e4848,
 839	0x8d04, 0xffffffff, 0x00164745,
 840	0x8c00, 0xffffffff, 0xe4000003,
 841	0x8cf0, 0x1fffffff, 0x08e00410,
 842	0x28350, 0xffffffff, 0x00000000,
 843	0x9508, 0xffffffff, 0x00000002,
 844	0x900c, 0xffffffff, 0x0017071f,
 845	0x8c18, 0xffffffff, 0x10101060,
 846	0x8c1c, 0xffffffff, 0x00001010
 847};
 848
 849static const u32 barts_golden_registers[] =
 850{
 851	0x5eb4, 0xffffffff, 0x00000002,
 852	0x5e78, 0x8f311ff1, 0x001000f0,
 853	0x3f90, 0xffff0000, 0xff000000,
 854	0x9148, 0xffff0000, 0xff000000,
 855	0x3f94, 0xffff0000, 0xff000000,
 856	0x914c, 0xffff0000, 0xff000000,
 857	0xc78, 0x00000080, 0x00000080,
 858	0xbd4, 0x70073777, 0x00010001,
 859	0xd02c, 0xbfffff1f, 0x08421000,
 860	0xd0b8, 0x03773777, 0x02011003,
 861	0x5bc0, 0x00200000, 0x50100000,
 862	0x98f8, 0x33773777, 0x02011003,
 863	0x98fc, 0xffffffff, 0x76543210,
 864	0x7030, 0x31000311, 0x00000011,
 865	0x2f48, 0x00000007, 0x02011003,
 866	0x6b28, 0x00000010, 0x00000012,
 867	0x7728, 0x00000010, 0x00000012,
 868	0x10328, 0x00000010, 0x00000012,
 869	0x10f28, 0x00000010, 0x00000012,
 870	0x11b28, 0x00000010, 0x00000012,
 871	0x12728, 0x00000010, 0x00000012,
 872	0x240c, 0x000007ff, 0x00000380,
 873	0x8a14, 0xf000001f, 0x00000007,
 874	0x8b24, 0x3fff3fff, 0x00ff0fff,
 875	0x8b10, 0x0000ff0f, 0x00000000,
 876	0x28a4c, 0x07ffffff, 0x06000000,
 877	0x10c, 0x00000001, 0x00010003,
 878	0xa02c, 0xffffffff, 0x0000009b,
 879	0x913c, 0x0000000f, 0x0100000a,
 880	0x8d00, 0xffff7f7f, 0x100e4848,
 881	0x8d04, 0x00ffffff, 0x00164745,
 882	0x8c00, 0xfffc0003, 0xe4000003,
 883	0x8c04, 0xf8ff00ff, 0x40600060,
 884	0x8c08, 0x00ff00ff, 0x001c001c,
 885	0x8cf0, 0x1fff1fff, 0x08e00620,
 886	0x8c20, 0x0fff0fff, 0x00800080,
 887	0x8c24, 0x0fff0fff, 0x00800080,
 888	0x8c18, 0xffffffff, 0x20202078,
 889	0x8c1c, 0x0000ffff, 0x00001010,
 890	0x28350, 0x00000f01, 0x00000000,
 891	0x9508, 0x3700001f, 0x00000002,
 892	0x960c, 0xffffffff, 0x54763210,
 893	0x88c4, 0x001f3ae3, 0x000000c2,
 894	0x88d4, 0x0000001f, 0x00000010,
 895	0x8974, 0xffffffff, 0x00000000
 896};
 897
 898static const u32 turks_golden_registers[] =
 899{
 900	0x5eb4, 0xffffffff, 0x00000002,
 901	0x5e78, 0x8f311ff1, 0x001000f0,
 902	0x8c8, 0x00003000, 0x00001070,
 903	0x8cc, 0x000fffff, 0x00040035,
 904	0x3f90, 0xffff0000, 0xfff00000,
 905	0x9148, 0xffff0000, 0xfff00000,
 906	0x3f94, 0xffff0000, 0xfff00000,
 907	0x914c, 0xffff0000, 0xfff00000,
 908	0xc78, 0x00000080, 0x00000080,
 909	0xbd4, 0x00073007, 0x00010002,
 910	0xd02c, 0xbfffff1f, 0x08421000,
 911	0xd0b8, 0x03773777, 0x02010002,
 912	0x5bc0, 0x00200000, 0x50100000,
 913	0x98f8, 0x33773777, 0x00010002,
 914	0x98fc, 0xffffffff, 0x33221100,
 915	0x7030, 0x31000311, 0x00000011,
 916	0x2f48, 0x33773777, 0x00010002,
 917	0x6b28, 0x00000010, 0x00000012,
 918	0x7728, 0x00000010, 0x00000012,
 919	0x10328, 0x00000010, 0x00000012,
 920	0x10f28, 0x00000010, 0x00000012,
 921	0x11b28, 0x00000010, 0x00000012,
 922	0x12728, 0x00000010, 0x00000012,
 923	0x240c, 0x000007ff, 0x00000380,
 924	0x8a14, 0xf000001f, 0x00000007,
 925	0x8b24, 0x3fff3fff, 0x00ff0fff,
 926	0x8b10, 0x0000ff0f, 0x00000000,
 927	0x28a4c, 0x07ffffff, 0x06000000,
 928	0x10c, 0x00000001, 0x00010003,
 929	0xa02c, 0xffffffff, 0x0000009b,
 930	0x913c, 0x0000000f, 0x0100000a,
 931	0x8d00, 0xffff7f7f, 0x100e4848,
 932	0x8d04, 0x00ffffff, 0x00164745,
 933	0x8c00, 0xfffc0003, 0xe4000003,
 934	0x8c04, 0xf8ff00ff, 0x40600060,
 935	0x8c08, 0x00ff00ff, 0x001c001c,
 936	0x8cf0, 0x1fff1fff, 0x08e00410,
 937	0x8c20, 0x0fff0fff, 0x00800080,
 938	0x8c24, 0x0fff0fff, 0x00800080,
 939	0x8c18, 0xffffffff, 0x20202078,
 940	0x8c1c, 0x0000ffff, 0x00001010,
 941	0x28350, 0x00000f01, 0x00000000,
 942	0x9508, 0x3700001f, 0x00000002,
 943	0x960c, 0xffffffff, 0x54763210,
 944	0x88c4, 0x001f3ae3, 0x000000c2,
 945	0x88d4, 0x0000001f, 0x00000010,
 946	0x8974, 0xffffffff, 0x00000000
 947};
 948
 949static const u32 caicos_golden_registers[] =
 950{
 951	0x5eb4, 0xffffffff, 0x00000002,
 952	0x5e78, 0x8f311ff1, 0x001000f0,
 953	0x8c8, 0x00003420, 0x00001450,
 954	0x8cc, 0x000fffff, 0x00040035,
 955	0x3f90, 0xffff0000, 0xfffc0000,
 956	0x9148, 0xffff0000, 0xfffc0000,
 957	0x3f94, 0xffff0000, 0xfffc0000,
 958	0x914c, 0xffff0000, 0xfffc0000,
 959	0xc78, 0x00000080, 0x00000080,
 960	0xbd4, 0x00073007, 0x00010001,
 961	0xd02c, 0xbfffff1f, 0x08421000,
 962	0xd0b8, 0x03773777, 0x02010001,
 963	0x5bc0, 0x00200000, 0x50100000,
 964	0x98f8, 0x33773777, 0x02010001,
 965	0x98fc, 0xffffffff, 0x33221100,
 966	0x7030, 0x31000311, 0x00000011,
 967	0x2f48, 0x33773777, 0x02010001,
 968	0x6b28, 0x00000010, 0x00000012,
 969	0x7728, 0x00000010, 0x00000012,
 970	0x10328, 0x00000010, 0x00000012,
 971	0x10f28, 0x00000010, 0x00000012,
 972	0x11b28, 0x00000010, 0x00000012,
 973	0x12728, 0x00000010, 0x00000012,
 974	0x240c, 0x000007ff, 0x00000380,
 975	0x8a14, 0xf000001f, 0x00000001,
 976	0x8b24, 0x3fff3fff, 0x00ff0fff,
 977	0x8b10, 0x0000ff0f, 0x00000000,
 978	0x28a4c, 0x07ffffff, 0x06000000,
 979	0x10c, 0x00000001, 0x00010003,
 980	0xa02c, 0xffffffff, 0x0000009b,
 981	0x913c, 0x0000000f, 0x0100000a,
 982	0x8d00, 0xffff7f7f, 0x100e4848,
 983	0x8d04, 0x00ffffff, 0x00164745,
 984	0x8c00, 0xfffc0003, 0xe4000003,
 985	0x8c04, 0xf8ff00ff, 0x40600060,
 986	0x8c08, 0x00ff00ff, 0x001c001c,
 987	0x8cf0, 0x1fff1fff, 0x08e00410,
 988	0x8c20, 0x0fff0fff, 0x00800080,
 989	0x8c24, 0x0fff0fff, 0x00800080,
 990	0x8c18, 0xffffffff, 0x20202078,
 991	0x8c1c, 0x0000ffff, 0x00001010,
 992	0x28350, 0x00000f01, 0x00000000,
 993	0x9508, 0x3700001f, 0x00000002,
 994	0x960c, 0xffffffff, 0x54763210,
 995	0x88c4, 0x001f3ae3, 0x000000c2,
 996	0x88d4, 0x0000001f, 0x00000010,
 997	0x8974, 0xffffffff, 0x00000000
 998};
 999
1000static void evergreen_init_golden_registers(struct radeon_device *rdev)
1001{
1002	switch (rdev->family) {
1003	case CHIP_CYPRESS:
1004	case CHIP_HEMLOCK:
1005		radeon_program_register_sequence(rdev,
1006						 evergreen_golden_registers,
1007						 (const u32)ARRAY_SIZE(evergreen_golden_registers));
1008		radeon_program_register_sequence(rdev,
1009						 evergreen_golden_registers2,
1010						 (const u32)ARRAY_SIZE(evergreen_golden_registers2));
1011		radeon_program_register_sequence(rdev,
1012						 cypress_mgcg_init,
1013						 (const u32)ARRAY_SIZE(cypress_mgcg_init));
1014		break;
1015	case CHIP_JUNIPER:
1016		radeon_program_register_sequence(rdev,
1017						 evergreen_golden_registers,
1018						 (const u32)ARRAY_SIZE(evergreen_golden_registers));
1019		radeon_program_register_sequence(rdev,
1020						 evergreen_golden_registers2,
1021						 (const u32)ARRAY_SIZE(evergreen_golden_registers2));
1022		radeon_program_register_sequence(rdev,
1023						 juniper_mgcg_init,
1024						 (const u32)ARRAY_SIZE(juniper_mgcg_init));
1025		break;
1026	case CHIP_REDWOOD:
1027		radeon_program_register_sequence(rdev,
1028						 evergreen_golden_registers,
1029						 (const u32)ARRAY_SIZE(evergreen_golden_registers));
1030		radeon_program_register_sequence(rdev,
1031						 evergreen_golden_registers2,
1032						 (const u32)ARRAY_SIZE(evergreen_golden_registers2));
1033		radeon_program_register_sequence(rdev,
1034						 redwood_mgcg_init,
1035						 (const u32)ARRAY_SIZE(redwood_mgcg_init));
1036		break;
1037	case CHIP_CEDAR:
1038		radeon_program_register_sequence(rdev,
1039						 cedar_golden_registers,
1040						 (const u32)ARRAY_SIZE(cedar_golden_registers));
1041		radeon_program_register_sequence(rdev,
1042						 evergreen_golden_registers2,
1043						 (const u32)ARRAY_SIZE(evergreen_golden_registers2));
1044		radeon_program_register_sequence(rdev,
1045						 cedar_mgcg_init,
1046						 (const u32)ARRAY_SIZE(cedar_mgcg_init));
1047		break;
1048	case CHIP_PALM:
1049		radeon_program_register_sequence(rdev,
1050						 wrestler_golden_registers,
1051						 (const u32)ARRAY_SIZE(wrestler_golden_registers));
1052		break;
1053	case CHIP_SUMO:
1054		radeon_program_register_sequence(rdev,
1055						 supersumo_golden_registers,
1056						 (const u32)ARRAY_SIZE(supersumo_golden_registers));
1057		break;
1058	case CHIP_SUMO2:
1059		radeon_program_register_sequence(rdev,
1060						 supersumo_golden_registers,
1061						 (const u32)ARRAY_SIZE(supersumo_golden_registers));
1062		radeon_program_register_sequence(rdev,
1063						 sumo_golden_registers,
1064						 (const u32)ARRAY_SIZE(sumo_golden_registers));
1065		break;
1066	case CHIP_BARTS:
1067		radeon_program_register_sequence(rdev,
1068						 barts_golden_registers,
1069						 (const u32)ARRAY_SIZE(barts_golden_registers));
1070		break;
1071	case CHIP_TURKS:
1072		radeon_program_register_sequence(rdev,
1073						 turks_golden_registers,
1074						 (const u32)ARRAY_SIZE(turks_golden_registers));
1075		break;
1076	case CHIP_CAICOS:
1077		radeon_program_register_sequence(rdev,
1078						 caicos_golden_registers,
1079						 (const u32)ARRAY_SIZE(caicos_golden_registers));
1080		break;
1081	default:
1082		break;
1083	}
1084}
1085
1086/**
1087 * evergreen_get_allowed_info_register - fetch the register for the info ioctl
1088 *
1089 * @rdev: radeon_device pointer
1090 * @reg: register offset in bytes
1091 * @val: register value
1092 *
1093 * Returns 0 for success or -EINVAL for an invalid register
1094 *
1095 */
1096int evergreen_get_allowed_info_register(struct radeon_device *rdev,
1097					u32 reg, u32 *val)
1098{
1099	switch (reg) {
1100	case GRBM_STATUS:
1101	case GRBM_STATUS_SE0:
1102	case GRBM_STATUS_SE1:
1103	case SRBM_STATUS:
1104	case SRBM_STATUS2:
1105	case DMA_STATUS_REG:
1106	case UVD_STATUS:
1107		*val = RREG32(reg);
1108		return 0;
1109	default:
1110		return -EINVAL;
1111	}
1112}
1113
1114void evergreen_tiling_fields(unsigned tiling_flags, unsigned *bankw,
1115			     unsigned *bankh, unsigned *mtaspect,
1116			     unsigned *tile_split)
1117{
1118	*bankw = (tiling_flags >> RADEON_TILING_EG_BANKW_SHIFT) & RADEON_TILING_EG_BANKW_MASK;
1119	*bankh = (tiling_flags >> RADEON_TILING_EG_BANKH_SHIFT) & RADEON_TILING_EG_BANKH_MASK;
1120	*mtaspect = (tiling_flags >> RADEON_TILING_EG_MACRO_TILE_ASPECT_SHIFT) & RADEON_TILING_EG_MACRO_TILE_ASPECT_MASK;
1121	*tile_split = (tiling_flags >> RADEON_TILING_EG_TILE_SPLIT_SHIFT) & RADEON_TILING_EG_TILE_SPLIT_MASK;
1122	switch (*bankw) {
1123	default:
1124	case 1: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_1; break;
1125	case 2: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_2; break;
1126	case 4: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_4; break;
1127	case 8: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_8; break;
1128	}
1129	switch (*bankh) {
1130	default:
1131	case 1: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_1; break;
1132	case 2: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_2; break;
1133	case 4: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_4; break;
1134	case 8: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_8; break;
1135	}
1136	switch (*mtaspect) {
1137	default:
1138	case 1: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_1; break;
1139	case 2: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_2; break;
1140	case 4: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_4; break;
1141	case 8: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_8; break;
1142	}
1143}
1144
1145static int sumo_set_uvd_clock(struct radeon_device *rdev, u32 clock,
1146			      u32 cntl_reg, u32 status_reg)
1147{
1148	int r, i;
1149	struct atom_clock_dividers dividers;
1150
1151	r = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM,
1152					   clock, false, &dividers);
1153	if (r)
1154		return r;
1155
1156	WREG32_P(cntl_reg, dividers.post_div, ~(DCLK_DIR_CNTL_EN|DCLK_DIVIDER_MASK));
1157
1158	for (i = 0; i < 100; i++) {
1159		if (RREG32(status_reg) & DCLK_STATUS)
1160			break;
1161		mdelay(10);
1162	}
1163	if (i == 100)
1164		return -ETIMEDOUT;
1165
1166	return 0;
1167}
1168
1169int sumo_set_uvd_clocks(struct radeon_device *rdev, u32 vclk, u32 dclk)
1170{
1171	int r = 0;
1172	u32 cg_scratch = RREG32(CG_SCRATCH1);
1173
1174	r = sumo_set_uvd_clock(rdev, vclk, CG_VCLK_CNTL, CG_VCLK_STATUS);
1175	if (r)
1176		goto done;
1177	cg_scratch &= 0xffff0000;
1178	cg_scratch |= vclk / 100; /* Mhz */
1179
1180	r = sumo_set_uvd_clock(rdev, dclk, CG_DCLK_CNTL, CG_DCLK_STATUS);
1181	if (r)
1182		goto done;
1183	cg_scratch &= 0x0000ffff;
1184	cg_scratch |= (dclk / 100) << 16; /* Mhz */
1185
1186done:
1187	WREG32(CG_SCRATCH1, cg_scratch);
1188
1189	return r;
1190}
1191
1192int evergreen_set_uvd_clocks(struct radeon_device *rdev, u32 vclk, u32 dclk)
1193{
1194	/* start off with something large */
1195	unsigned fb_div = 0, vclk_div = 0, dclk_div = 0;
1196	int r;
1197
1198	/* bypass vclk and dclk with bclk */
1199	WREG32_P(CG_UPLL_FUNC_CNTL_2,
1200		VCLK_SRC_SEL(1) | DCLK_SRC_SEL(1),
1201		~(VCLK_SRC_SEL_MASK | DCLK_SRC_SEL_MASK));
1202
1203	/* put PLL in bypass mode */
1204	WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_BYPASS_EN_MASK, ~UPLL_BYPASS_EN_MASK);
1205
1206	if (!vclk || !dclk) {
1207		/* keep the Bypass mode, put PLL to sleep */
1208		WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_SLEEP_MASK, ~UPLL_SLEEP_MASK);
1209		return 0;
1210	}
1211
1212	r = radeon_uvd_calc_upll_dividers(rdev, vclk, dclk, 125000, 250000,
1213					  16384, 0x03FFFFFF, 0, 128, 5,
1214					  &fb_div, &vclk_div, &dclk_div);
1215	if (r)
1216		return r;
1217
1218	/* set VCO_MODE to 1 */
1219	WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_VCO_MODE_MASK, ~UPLL_VCO_MODE_MASK);
1220
1221	/* toggle UPLL_SLEEP to 1 then back to 0 */
1222	WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_SLEEP_MASK, ~UPLL_SLEEP_MASK);
1223	WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_SLEEP_MASK);
1224
1225	/* deassert UPLL_RESET */
1226	WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_RESET_MASK);
1227
1228	mdelay(1);
1229
1230	r = radeon_uvd_send_upll_ctlreq(rdev, CG_UPLL_FUNC_CNTL);
1231	if (r)
1232		return r;
1233
1234	/* assert UPLL_RESET again */
1235	WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_RESET_MASK, ~UPLL_RESET_MASK);
1236
1237	/* disable spread spectrum. */
1238	WREG32_P(CG_UPLL_SPREAD_SPECTRUM, 0, ~SSEN_MASK);
1239
1240	/* set feedback divider */
1241	WREG32_P(CG_UPLL_FUNC_CNTL_3, UPLL_FB_DIV(fb_div), ~UPLL_FB_DIV_MASK);
1242
1243	/* set ref divider to 0 */
1244	WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_REF_DIV_MASK);
1245
1246	if (fb_div < 307200)
1247		WREG32_P(CG_UPLL_FUNC_CNTL_4, 0, ~UPLL_SPARE_ISPARE9);
1248	else
1249		WREG32_P(CG_UPLL_FUNC_CNTL_4, UPLL_SPARE_ISPARE9, ~UPLL_SPARE_ISPARE9);
1250
1251	/* set PDIV_A and PDIV_B */
1252	WREG32_P(CG_UPLL_FUNC_CNTL_2,
1253		UPLL_PDIV_A(vclk_div) | UPLL_PDIV_B(dclk_div),
1254		~(UPLL_PDIV_A_MASK | UPLL_PDIV_B_MASK));
1255
1256	/* give the PLL some time to settle */
1257	mdelay(15);
1258
1259	/* deassert PLL_RESET */
1260	WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_RESET_MASK);
1261
1262	mdelay(15);
1263
1264	/* switch from bypass mode to normal mode */
1265	WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_BYPASS_EN_MASK);
1266
1267	r = radeon_uvd_send_upll_ctlreq(rdev, CG_UPLL_FUNC_CNTL);
1268	if (r)
1269		return r;
1270
1271	/* switch VCLK and DCLK selection */
1272	WREG32_P(CG_UPLL_FUNC_CNTL_2,
1273		VCLK_SRC_SEL(2) | DCLK_SRC_SEL(2),
1274		~(VCLK_SRC_SEL_MASK | DCLK_SRC_SEL_MASK));
1275
1276	mdelay(100);
1277
1278	return 0;
1279}
1280
1281void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
1282{
1283	int readrq;
1284	u16 v;
1285
1286	readrq = pcie_get_readrq(rdev->pdev);
1287	v = ffs(readrq) - 8;
1288	/* if bios or OS sets MAX_READ_REQUEST_SIZE to an invalid value, fix it
1289	 * to avoid hangs or perfomance issues
1290	 */
1291	if ((v == 0) || (v == 6) || (v == 7))
1292		pcie_set_readrq(rdev->pdev, 512);
1293}
1294
1295void dce4_program_fmt(struct drm_encoder *encoder)
1296{
1297	struct drm_device *dev = encoder->dev;
1298	struct radeon_device *rdev = dev->dev_private;
1299	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
1300	struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
1301	struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
1302	int bpc = 0;
1303	u32 tmp = 0;
1304	enum radeon_connector_dither dither = RADEON_FMT_DITHER_DISABLE;
1305
1306	if (connector) {
1307		struct radeon_connector *radeon_connector = to_radeon_connector(connector);
1308		bpc = radeon_get_monitor_bpc(connector);
1309		dither = radeon_connector->dither;
1310	}
1311
1312	/* LVDS/eDP FMT is set up by atom */
1313	if (radeon_encoder->devices & ATOM_DEVICE_LCD_SUPPORT)
1314		return;
1315
1316	/* not needed for analog */
1317	if ((radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1) ||
1318	    (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2))
1319		return;
1320
1321	if (bpc == 0)
1322		return;
1323
1324	switch (bpc) {
1325	case 6:
1326		if (dither == RADEON_FMT_DITHER_ENABLE)
1327			/* XXX sort out optimal dither settings */
1328			tmp |= (FMT_FRAME_RANDOM_ENABLE | FMT_HIGHPASS_RANDOM_ENABLE |
1329				FMT_SPATIAL_DITHER_EN);
1330		else
1331			tmp |= FMT_TRUNCATE_EN;
1332		break;
1333	case 8:
1334		if (dither == RADEON_FMT_DITHER_ENABLE)
1335			/* XXX sort out optimal dither settings */
1336			tmp |= (FMT_FRAME_RANDOM_ENABLE | FMT_HIGHPASS_RANDOM_ENABLE |
1337				FMT_RGB_RANDOM_ENABLE |
1338				FMT_SPATIAL_DITHER_EN | FMT_SPATIAL_DITHER_DEPTH);
1339		else
1340			tmp |= (FMT_TRUNCATE_EN | FMT_TRUNCATE_DEPTH);
1341		break;
1342	case 10:
1343	default:
1344		/* not needed */
1345		break;
1346	}
1347
1348	WREG32(FMT_BIT_DEPTH_CONTROL + radeon_crtc->crtc_offset, tmp);
1349}
1350
1351static bool dce4_is_in_vblank(struct radeon_device *rdev, int crtc)
1352{
1353	if (RREG32(EVERGREEN_CRTC_STATUS + crtc_offsets[crtc]) & EVERGREEN_CRTC_V_BLANK)
1354		return true;
1355	else
1356		return false;
1357}
1358
1359static bool dce4_is_counter_moving(struct radeon_device *rdev, int crtc)
1360{
1361	u32 pos1, pos2;
1362
1363	pos1 = RREG32(EVERGREEN_CRTC_STATUS_POSITION + crtc_offsets[crtc]);
1364	pos2 = RREG32(EVERGREEN_CRTC_STATUS_POSITION + crtc_offsets[crtc]);
1365
1366	if (pos1 != pos2)
1367		return true;
1368	else
1369		return false;
1370}
1371
1372/**
1373 * dce4_wait_for_vblank - vblank wait asic callback.
1374 *
1375 * @rdev: radeon_device pointer
1376 * @crtc: crtc to wait for vblank on
1377 *
1378 * Wait for vblank on the requested crtc (evergreen+).
1379 */
1380void dce4_wait_for_vblank(struct radeon_device *rdev, int crtc)
1381{
1382	unsigned i = 0;
1383
1384	if (crtc >= rdev->num_crtc)
1385		return;
1386
1387	if (!(RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[crtc]) & EVERGREEN_CRTC_MASTER_EN))
1388		return;
1389
1390	/* depending on when we hit vblank, we may be close to active; if so,
1391	 * wait for another frame.
1392	 */
1393	while (dce4_is_in_vblank(rdev, crtc)) {
1394		if (i++ % 100 == 0) {
1395			if (!dce4_is_counter_moving(rdev, crtc))
1396				break;
1397		}
1398	}
1399
1400	while (!dce4_is_in_vblank(rdev, crtc)) {
1401		if (i++ % 100 == 0) {
1402			if (!dce4_is_counter_moving(rdev, crtc))
1403				break;
1404		}
1405	}
1406}
1407
1408/**
1409 * evergreen_page_flip - pageflip callback.
1410 *
1411 * @rdev: radeon_device pointer
1412 * @crtc_id: crtc to cleanup pageflip on
1413 * @crtc_base: new address of the crtc (GPU MC address)
1414 *
1415 * Triggers the actual pageflip by updating the primary
1416 * surface base address (evergreen+).
1417 */
1418void evergreen_page_flip(struct radeon_device *rdev, int crtc_id, u64 crtc_base,
1419			 bool async)
1420{
1421	struct radeon_crtc *radeon_crtc = rdev->mode_info.crtcs[crtc_id];
1422
1423	/* update the scanout addresses */
1424	WREG32(EVERGREEN_GRPH_FLIP_CONTROL + radeon_crtc->crtc_offset,
1425	       async ? EVERGREEN_GRPH_SURFACE_UPDATE_H_RETRACE_EN : 0);
1426	WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS_HIGH + radeon_crtc->crtc_offset,
1427	       upper_32_bits(crtc_base));
1428	WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS + radeon_crtc->crtc_offset,
1429	       (u32)crtc_base);
1430	/* post the write */
1431	RREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS + radeon_crtc->crtc_offset);
1432}
1433
1434/**
1435 * evergreen_page_flip_pending - check if page flip is still pending
1436 *
1437 * @rdev: radeon_device pointer
1438 * @crtc_id: crtc to check
1439 *
1440 * Returns the current update pending status.
1441 */
1442bool evergreen_page_flip_pending(struct radeon_device *rdev, int crtc_id)
1443{
1444	struct radeon_crtc *radeon_crtc = rdev->mode_info.crtcs[crtc_id];
1445
1446	/* Return current update_pending status: */
1447	return !!(RREG32(EVERGREEN_GRPH_UPDATE + radeon_crtc->crtc_offset) &
1448		EVERGREEN_GRPH_SURFACE_UPDATE_PENDING);
1449}
1450
1451/* get temperature in millidegrees */
1452int evergreen_get_temp(struct radeon_device *rdev)
1453{
1454	u32 temp, toffset;
1455	int actual_temp = 0;
1456
1457	if (rdev->family == CHIP_JUNIPER) {
1458		toffset = (RREG32(CG_THERMAL_CTRL) & TOFFSET_MASK) >>
1459			TOFFSET_SHIFT;
1460		temp = (RREG32(CG_TS0_STATUS) & TS0_ADC_DOUT_MASK) >>
1461			TS0_ADC_DOUT_SHIFT;
1462
1463		if (toffset & 0x100)
1464			actual_temp = temp / 2 - (0x200 - toffset);
1465		else
1466			actual_temp = temp / 2 + toffset;
1467
1468		actual_temp = actual_temp * 1000;
1469
1470	} else {
1471		temp = (RREG32(CG_MULT_THERMAL_STATUS) & ASIC_T_MASK) >>
1472			ASIC_T_SHIFT;
1473
1474		if (temp & 0x400)
1475			actual_temp = -256;
1476		else if (temp & 0x200)
1477			actual_temp = 255;
1478		else if (temp & 0x100) {
1479			actual_temp = temp & 0x1ff;
1480			actual_temp |= ~0x1ff;
1481		} else
1482			actual_temp = temp & 0xff;
1483
1484		actual_temp = (actual_temp * 1000) / 2;
1485	}
1486
1487	return actual_temp;
1488}
1489
1490int sumo_get_temp(struct radeon_device *rdev)
1491{
1492	u32 temp = RREG32(CG_THERMAL_STATUS) & 0xff;
1493	int actual_temp = temp - 49;
1494
1495	return actual_temp * 1000;
1496}
1497
1498/**
1499 * sumo_pm_init_profile - Initialize power profiles callback.
1500 *
1501 * @rdev: radeon_device pointer
1502 *
1503 * Initialize the power states used in profile mode
1504 * (sumo, trinity, SI).
1505 * Used for profile mode only.
1506 */
1507void sumo_pm_init_profile(struct radeon_device *rdev)
1508{
1509	int idx;
1510
1511	/* default */
1512	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_ps_idx = rdev->pm.default_power_state_index;
1513	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_ps_idx = rdev->pm.default_power_state_index;
1514	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_cm_idx = 0;
1515	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_cm_idx = 0;
1516
1517	/* low,mid sh/mh */
1518	if (rdev->flags & RADEON_IS_MOBILITY)
1519		idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_BATTERY, 0);
1520	else
1521		idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_PERFORMANCE, 0);
1522
1523	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_ps_idx = idx;
1524	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_ps_idx = idx;
1525	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_cm_idx = 0;
1526	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_cm_idx = 0;
1527
1528	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_ps_idx = idx;
1529	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_ps_idx = idx;
1530	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_cm_idx = 0;
1531	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_cm_idx = 0;
1532
1533	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_ps_idx = idx;
1534	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_ps_idx = idx;
1535	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_cm_idx = 0;
1536	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_cm_idx = 0;
1537
1538	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_ps_idx = idx;
1539	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_ps_idx = idx;
1540	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_cm_idx = 0;
1541	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_cm_idx = 0;
1542
1543	/* high sh/mh */
1544	idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_PERFORMANCE, 0);
1545	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_ps_idx = idx;
1546	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_ps_idx = idx;
1547	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_cm_idx = 0;
1548	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_cm_idx =
1549		rdev->pm.power_state[idx].num_clock_modes - 1;
1550
1551	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_ps_idx = idx;
1552	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_ps_idx = idx;
1553	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_cm_idx = 0;
1554	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_cm_idx =
1555		rdev->pm.power_state[idx].num_clock_modes - 1;
1556}
1557
1558/**
1559 * btc_pm_init_profile - Initialize power profiles callback.
1560 *
1561 * @rdev: radeon_device pointer
1562 *
1563 * Initialize the power states used in profile mode
1564 * (BTC, cayman).
1565 * Used for profile mode only.
1566 */
1567void btc_pm_init_profile(struct radeon_device *rdev)
1568{
1569	int idx;
1570
1571	/* default */
1572	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_ps_idx = rdev->pm.default_power_state_index;
1573	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_ps_idx = rdev->pm.default_power_state_index;
1574	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_cm_idx = 0;
1575	rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_cm_idx = 2;
1576	/* starting with BTC, there is one state that is used for both
1577	 * MH and SH.  Difference is that we always use the high clock index for
1578	 * mclk.
1579	 */
1580	if (rdev->flags & RADEON_IS_MOBILITY)
1581		idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_BATTERY, 0);
1582	else
1583		idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_PERFORMANCE, 0);
1584	/* low sh */
1585	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_ps_idx = idx;
1586	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_ps_idx = idx;
1587	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_cm_idx = 0;
1588	rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_cm_idx = 0;
1589	/* mid sh */
1590	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_ps_idx = idx;
1591	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_ps_idx = idx;
1592	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_cm_idx = 0;
1593	rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_cm_idx = 1;
1594	/* high sh */
1595	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_ps_idx = idx;
1596	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_ps_idx = idx;
1597	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_cm_idx = 0;
1598	rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_cm_idx = 2;
1599	/* low mh */
1600	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_ps_idx = idx;
1601	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_ps_idx = idx;
1602	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_cm_idx = 0;
1603	rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_cm_idx = 0;
1604	/* mid mh */
1605	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_ps_idx = idx;
1606	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_ps_idx = idx;
1607	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_cm_idx = 0;
1608	rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_cm_idx = 1;
1609	/* high mh */
1610	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_ps_idx = idx;
1611	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_ps_idx = idx;
1612	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_cm_idx = 0;
1613	rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_cm_idx = 2;
1614}
1615
1616/**
1617 * evergreen_pm_misc - set additional pm hw parameters callback.
1618 *
1619 * @rdev: radeon_device pointer
1620 *
1621 * Set non-clock parameters associated with a power state
1622 * (voltage, etc.) (evergreen+).
1623 */
1624void evergreen_pm_misc(struct radeon_device *rdev)
1625{
1626	int req_ps_idx = rdev->pm.requested_power_state_index;
1627	int req_cm_idx = rdev->pm.requested_clock_mode_index;
1628	struct radeon_power_state *ps = &rdev->pm.power_state[req_ps_idx];
1629	struct radeon_voltage *voltage = &ps->clock_info[req_cm_idx].voltage;
1630
1631	if (voltage->type == VOLTAGE_SW) {
1632		/* 0xff0x are flags rather then an actual voltage */
1633		if ((voltage->voltage & 0xff00) == 0xff00)
1634			return;
1635		if (voltage->voltage && (voltage->voltage != rdev->pm.current_vddc)) {
1636			radeon_atom_set_voltage(rdev, voltage->voltage, SET_VOLTAGE_TYPE_ASIC_VDDC);
1637			rdev->pm.current_vddc = voltage->voltage;
1638			DRM_DEBUG("Setting: vddc: %d\n", voltage->voltage);
1639		}
1640
1641		/* starting with BTC, there is one state that is used for both
1642		 * MH and SH.  Difference is that we always use the high clock index for
1643		 * mclk and vddci.
1644		 */
1645		if ((rdev->pm.pm_method == PM_METHOD_PROFILE) &&
1646		    (rdev->family >= CHIP_BARTS) &&
1647		    rdev->pm.active_crtc_count &&
1648		    ((rdev->pm.profile_index == PM_PROFILE_MID_MH_IDX) ||
1649		     (rdev->pm.profile_index == PM_PROFILE_LOW_MH_IDX)))
1650			voltage = &rdev->pm.power_state[req_ps_idx].
1651				clock_info[rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_cm_idx].voltage;
1652
1653		/* 0xff0x are flags rather then an actual voltage */
1654		if ((voltage->vddci & 0xff00) == 0xff00)
1655			return;
1656		if (voltage->vddci && (voltage->vddci != rdev->pm.current_vddci)) {
1657			radeon_atom_set_voltage(rdev, voltage->vddci, SET_VOLTAGE_TYPE_ASIC_VDDCI);
1658			rdev->pm.current_vddci = voltage->vddci;
1659			DRM_DEBUG("Setting: vddci: %d\n", voltage->vddci);
1660		}
1661	}
1662}
1663
1664/**
1665 * evergreen_pm_prepare - pre-power state change callback.
1666 *
1667 * @rdev: radeon_device pointer
1668 *
1669 * Prepare for a power state change (evergreen+).
1670 */
1671void evergreen_pm_prepare(struct radeon_device *rdev)
1672{
1673	struct drm_device *ddev = rdev->ddev;
1674	struct drm_crtc *crtc;
1675	struct radeon_crtc *radeon_crtc;
1676	u32 tmp;
1677
1678	/* disable any active CRTCs */
1679	list_for_each_entry(crtc, &ddev->mode_config.crtc_list, head) {
1680		radeon_crtc = to_radeon_crtc(crtc);
1681		if (radeon_crtc->enabled) {
1682			tmp = RREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset);
1683			tmp |= EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE;
1684			WREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset, tmp);
1685		}
1686	}
1687}
1688
1689/**
1690 * evergreen_pm_finish - post-power state change callback.
1691 *
1692 * @rdev: radeon_device pointer
1693 *
1694 * Clean up after a power state change (evergreen+).
1695 */
1696void evergreen_pm_finish(struct radeon_device *rdev)
1697{
1698	struct drm_device *ddev = rdev->ddev;
1699	struct drm_crtc *crtc;
1700	struct radeon_crtc *radeon_crtc;
1701	u32 tmp;
1702
1703	/* enable any active CRTCs */
1704	list_for_each_entry(crtc, &ddev->mode_config.crtc_list, head) {
1705		radeon_crtc = to_radeon_crtc(crtc);
1706		if (radeon_crtc->enabled) {
1707			tmp = RREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset);
1708			tmp &= ~EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE;
1709			WREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset, tmp);
1710		}
1711	}
1712}
1713
1714/**
1715 * evergreen_hpd_sense - hpd sense callback.
1716 *
1717 * @rdev: radeon_device pointer
1718 * @hpd: hpd (hotplug detect) pin
1719 *
1720 * Checks if a digital monitor is connected (evergreen+).
1721 * Returns true if connected, false if not connected.
1722 */
1723bool evergreen_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd)
1724{
1725	if (hpd == RADEON_HPD_NONE)
1726		return false;
1727
1728	return !!(RREG32(DC_HPDx_INT_STATUS_REG(hpd)) & DC_HPDx_SENSE);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1729}
1730
1731/**
1732 * evergreen_hpd_set_polarity - hpd set polarity callback.
1733 *
1734 * @rdev: radeon_device pointer
1735 * @hpd: hpd (hotplug detect) pin
1736 *
1737 * Set the polarity of the hpd pin (evergreen+).
1738 */
1739void evergreen_hpd_set_polarity(struct radeon_device *rdev,
1740				enum radeon_hpd_id hpd)
1741{
 
1742	bool connected = evergreen_hpd_sense(rdev, hpd);
1743
1744	if (hpd == RADEON_HPD_NONE)
1745		return;
1746
1747	if (connected)
1748		WREG32_AND(DC_HPDx_INT_CONTROL(hpd), ~DC_HPDx_INT_POLARITY);
1749	else
1750		WREG32_OR(DC_HPDx_INT_CONTROL(hpd), DC_HPDx_INT_POLARITY);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1751}
1752
1753/**
1754 * evergreen_hpd_init - hpd setup callback.
1755 *
1756 * @rdev: radeon_device pointer
1757 *
1758 * Setup the hpd pins used by the card (evergreen+).
1759 * Enable the pin, set the polarity, and enable the hpd interrupts.
1760 */
1761void evergreen_hpd_init(struct radeon_device *rdev)
1762{
1763	struct drm_device *dev = rdev->ddev;
1764	struct drm_connector *connector;
1765	unsigned enabled = 0;
1766	u32 tmp = DC_HPDx_CONNECTION_TIMER(0x9c4) |
1767		DC_HPDx_RX_INT_TIMER(0xfa) | DC_HPDx_EN;
1768
1769	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1770		enum radeon_hpd_id hpd =
1771			to_radeon_connector(connector)->hpd.hpd;
1772
1773		if (connector->connector_type == DRM_MODE_CONNECTOR_eDP ||
1774		    connector->connector_type == DRM_MODE_CONNECTOR_LVDS) {
1775			/* don't try to enable hpd on eDP or LVDS avoid breaking the
1776			 * aux dp channel on imac and help (but not completely fix)
1777			 * https://bugzilla.redhat.com/show_bug.cgi?id=726143
1778			 * also avoid interrupt storms during dpms.
1779			 */
1780			continue;
1781		}
1782
1783		if (hpd == RADEON_HPD_NONE)
1784			continue;
1785
1786		WREG32(DC_HPDx_CONTROL(hpd), tmp);
1787		enabled |= 1 << hpd;
1788
1789		radeon_hpd_set_polarity(rdev, hpd);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1790	}
1791	radeon_irq_kms_enable_hpd(rdev, enabled);
1792}
1793
1794/**
1795 * evergreen_hpd_fini - hpd tear down callback.
1796 *
1797 * @rdev: radeon_device pointer
1798 *
1799 * Tear down the hpd pins used by the card (evergreen+).
1800 * Disable the hpd interrupts.
1801 */
1802void evergreen_hpd_fini(struct radeon_device *rdev)
1803{
1804	struct drm_device *dev = rdev->ddev;
1805	struct drm_connector *connector;
1806	unsigned disabled = 0;
1807
1808	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1809		enum radeon_hpd_id hpd =
1810			to_radeon_connector(connector)->hpd.hpd;
1811
1812		if (hpd == RADEON_HPD_NONE)
1813			continue;
1814
1815		WREG32(DC_HPDx_CONTROL(hpd), 0);
1816		disabled |= 1 << hpd;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1817	}
1818	radeon_irq_kms_disable_hpd(rdev, disabled);
1819}
1820
1821/* watermark setup */
1822
1823static u32 evergreen_line_buffer_adjust(struct radeon_device *rdev,
1824					struct radeon_crtc *radeon_crtc,
1825					struct drm_display_mode *mode,
1826					struct drm_display_mode *other_mode)
1827{
1828	u32 tmp, buffer_alloc, i;
1829	u32 pipe_offset = radeon_crtc->crtc_id * 0x20;
1830	/*
1831	 * Line Buffer Setup
1832	 * There are 3 line buffers, each one shared by 2 display controllers.
1833	 * DC_LB_MEMORY_SPLIT controls how that line buffer is shared between
1834	 * the display controllers.  The paritioning is done via one of four
1835	 * preset allocations specified in bits 2:0:
1836	 * first display controller
1837	 *  0 - first half of lb (3840 * 2)
1838	 *  1 - first 3/4 of lb (5760 * 2)
1839	 *  2 - whole lb (7680 * 2), other crtc must be disabled
1840	 *  3 - first 1/4 of lb (1920 * 2)
1841	 * second display controller
1842	 *  4 - second half of lb (3840 * 2)
1843	 *  5 - second 3/4 of lb (5760 * 2)
1844	 *  6 - whole lb (7680 * 2), other crtc must be disabled
1845	 *  7 - last 1/4 of lb (1920 * 2)
1846	 */
1847	/* this can get tricky if we have two large displays on a paired group
1848	 * of crtcs.  Ideally for multiple large displays we'd assign them to
1849	 * non-linked crtcs for maximum line buffer allocation.
1850	 */
1851	if (radeon_crtc->base.enabled && mode) {
1852		if (other_mode) {
1853			tmp = 0; /* 1/2 */
1854			buffer_alloc = 1;
1855		} else {
1856			tmp = 2; /* whole */
1857			buffer_alloc = 2;
1858		}
1859	} else {
1860		tmp = 0;
1861		buffer_alloc = 0;
1862	}
1863
1864	/* second controller of the pair uses second half of the lb */
1865	if (radeon_crtc->crtc_id % 2)
1866		tmp += 4;
1867	WREG32(DC_LB_MEMORY_SPLIT + radeon_crtc->crtc_offset, tmp);
1868
1869	if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
1870		WREG32(PIPE0_DMIF_BUFFER_CONTROL + pipe_offset,
1871		       DMIF_BUFFERS_ALLOCATED(buffer_alloc));
1872		for (i = 0; i < rdev->usec_timeout; i++) {
1873			if (RREG32(PIPE0_DMIF_BUFFER_CONTROL + pipe_offset) &
1874			    DMIF_BUFFERS_ALLOCATED_COMPLETED)
1875				break;
1876			udelay(1);
1877		}
1878	}
1879
1880	if (radeon_crtc->base.enabled && mode) {
1881		switch (tmp) {
1882		case 0:
1883		case 4:
1884		default:
1885			if (ASIC_IS_DCE5(rdev))
1886				return 4096 * 2;
1887			else
1888				return 3840 * 2;
1889		case 1:
1890		case 5:
1891			if (ASIC_IS_DCE5(rdev))
1892				return 6144 * 2;
1893			else
1894				return 5760 * 2;
1895		case 2:
1896		case 6:
1897			if (ASIC_IS_DCE5(rdev))
1898				return 8192 * 2;
1899			else
1900				return 7680 * 2;
1901		case 3:
1902		case 7:
1903			if (ASIC_IS_DCE5(rdev))
1904				return 2048 * 2;
1905			else
1906				return 1920 * 2;
1907		}
1908	}
1909
1910	/* controller not enabled, so no lb used */
1911	return 0;
1912}
1913
1914u32 evergreen_get_number_of_dram_channels(struct radeon_device *rdev)
1915{
1916	u32 tmp = RREG32(MC_SHARED_CHMAP);
1917
1918	switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) {
1919	case 0:
1920	default:
1921		return 1;
1922	case 1:
1923		return 2;
1924	case 2:
1925		return 4;
1926	case 3:
1927		return 8;
1928	}
1929}
1930
1931struct evergreen_wm_params {
1932	u32 dram_channels; /* number of dram channels */
1933	u32 yclk;          /* bandwidth per dram data pin in kHz */
1934	u32 sclk;          /* engine clock in kHz */
1935	u32 disp_clk;      /* display clock in kHz */
1936	u32 src_width;     /* viewport width */
1937	u32 active_time;   /* active display time in ns */
1938	u32 blank_time;    /* blank time in ns */
1939	bool interlaced;    /* mode is interlaced */
1940	fixed20_12 vsc;    /* vertical scale ratio */
1941	u32 num_heads;     /* number of active crtcs */
1942	u32 bytes_per_pixel; /* bytes per pixel display + overlay */
1943	u32 lb_size;       /* line buffer allocated to pipe */
1944	u32 vtaps;         /* vertical scaler taps */
1945};
1946
1947static u32 evergreen_dram_bandwidth(struct evergreen_wm_params *wm)
1948{
1949	/* Calculate DRAM Bandwidth and the part allocated to display. */
1950	fixed20_12 dram_efficiency; /* 0.7 */
1951	fixed20_12 yclk, dram_channels, bandwidth;
1952	fixed20_12 a;
1953
1954	a.full = dfixed_const(1000);
1955	yclk.full = dfixed_const(wm->yclk);
1956	yclk.full = dfixed_div(yclk, a);
1957	dram_channels.full = dfixed_const(wm->dram_channels * 4);
1958	a.full = dfixed_const(10);
1959	dram_efficiency.full = dfixed_const(7);
1960	dram_efficiency.full = dfixed_div(dram_efficiency, a);
1961	bandwidth.full = dfixed_mul(dram_channels, yclk);
1962	bandwidth.full = dfixed_mul(bandwidth, dram_efficiency);
1963
1964	return dfixed_trunc(bandwidth);
1965}
1966
1967static u32 evergreen_dram_bandwidth_for_display(struct evergreen_wm_params *wm)
1968{
1969	/* Calculate DRAM Bandwidth and the part allocated to display. */
1970	fixed20_12 disp_dram_allocation; /* 0.3 to 0.7 */
1971	fixed20_12 yclk, dram_channels, bandwidth;
1972	fixed20_12 a;
1973
1974	a.full = dfixed_const(1000);
1975	yclk.full = dfixed_const(wm->yclk);
1976	yclk.full = dfixed_div(yclk, a);
1977	dram_channels.full = dfixed_const(wm->dram_channels * 4);
1978	a.full = dfixed_const(10);
1979	disp_dram_allocation.full = dfixed_const(3); /* XXX worse case value 0.3 */
1980	disp_dram_allocation.full = dfixed_div(disp_dram_allocation, a);
1981	bandwidth.full = dfixed_mul(dram_channels, yclk);
1982	bandwidth.full = dfixed_mul(bandwidth, disp_dram_allocation);
1983
1984	return dfixed_trunc(bandwidth);
1985}
1986
1987static u32 evergreen_data_return_bandwidth(struct evergreen_wm_params *wm)
1988{
1989	/* Calculate the display Data return Bandwidth */
1990	fixed20_12 return_efficiency; /* 0.8 */
1991	fixed20_12 sclk, bandwidth;
1992	fixed20_12 a;
1993
1994	a.full = dfixed_const(1000);
1995	sclk.full = dfixed_const(wm->sclk);
1996	sclk.full = dfixed_div(sclk, a);
1997	a.full = dfixed_const(10);
1998	return_efficiency.full = dfixed_const(8);
1999	return_efficiency.full = dfixed_div(return_efficiency, a);
2000	a.full = dfixed_const(32);
2001	bandwidth.full = dfixed_mul(a, sclk);
2002	bandwidth.full = dfixed_mul(bandwidth, return_efficiency);
2003
2004	return dfixed_trunc(bandwidth);
2005}
2006
2007static u32 evergreen_dmif_request_bandwidth(struct evergreen_wm_params *wm)
2008{
2009	/* Calculate the DMIF Request Bandwidth */
2010	fixed20_12 disp_clk_request_efficiency; /* 0.8 */
2011	fixed20_12 disp_clk, bandwidth;
2012	fixed20_12 a;
2013
2014	a.full = dfixed_const(1000);
2015	disp_clk.full = dfixed_const(wm->disp_clk);
2016	disp_clk.full = dfixed_div(disp_clk, a);
2017	a.full = dfixed_const(10);
2018	disp_clk_request_efficiency.full = dfixed_const(8);
2019	disp_clk_request_efficiency.full = dfixed_div(disp_clk_request_efficiency, a);
2020	a.full = dfixed_const(32);
2021	bandwidth.full = dfixed_mul(a, disp_clk);
2022	bandwidth.full = dfixed_mul(bandwidth, disp_clk_request_efficiency);
2023
2024	return dfixed_trunc(bandwidth);
2025}
2026
2027static u32 evergreen_available_bandwidth(struct evergreen_wm_params *wm)
2028{
2029	/* Calculate the Available bandwidth. Display can use this temporarily but not in average. */
2030	u32 dram_bandwidth = evergreen_dram_bandwidth(wm);
2031	u32 data_return_bandwidth = evergreen_data_return_bandwidth(wm);
2032	u32 dmif_req_bandwidth = evergreen_dmif_request_bandwidth(wm);
2033
2034	return min(dram_bandwidth, min(data_return_bandwidth, dmif_req_bandwidth));
2035}
2036
2037static u32 evergreen_average_bandwidth(struct evergreen_wm_params *wm)
2038{
2039	/* Calculate the display mode Average Bandwidth
2040	 * DisplayMode should contain the source and destination dimensions,
2041	 * timing, etc.
2042	 */
2043	fixed20_12 bpp;
2044	fixed20_12 line_time;
2045	fixed20_12 src_width;
2046	fixed20_12 bandwidth;
2047	fixed20_12 a;
2048
2049	a.full = dfixed_const(1000);
2050	line_time.full = dfixed_const(wm->active_time + wm->blank_time);
2051	line_time.full = dfixed_div(line_time, a);
2052	bpp.full = dfixed_const(wm->bytes_per_pixel);
2053	src_width.full = dfixed_const(wm->src_width);
2054	bandwidth.full = dfixed_mul(src_width, bpp);
2055	bandwidth.full = dfixed_mul(bandwidth, wm->vsc);
2056	bandwidth.full = dfixed_div(bandwidth, line_time);
2057
2058	return dfixed_trunc(bandwidth);
2059}
2060
2061static u32 evergreen_latency_watermark(struct evergreen_wm_params *wm)
2062{
2063	/* First calcualte the latency in ns */
2064	u32 mc_latency = 2000; /* 2000 ns. */
2065	u32 available_bandwidth = evergreen_available_bandwidth(wm);
2066	u32 worst_chunk_return_time = (512 * 8 * 1000) / available_bandwidth;
2067	u32 cursor_line_pair_return_time = (128 * 4 * 1000) / available_bandwidth;
2068	u32 dc_latency = 40000000 / wm->disp_clk; /* dc pipe latency */
2069	u32 other_heads_data_return_time = ((wm->num_heads + 1) * worst_chunk_return_time) +
2070		(wm->num_heads * cursor_line_pair_return_time);
2071	u32 latency = mc_latency + other_heads_data_return_time + dc_latency;
2072	u32 max_src_lines_per_dst_line, lb_fill_bw, line_fill_time;
2073	fixed20_12 a, b, c;
2074
2075	if (wm->num_heads == 0)
2076		return 0;
2077
2078	a.full = dfixed_const(2);
2079	b.full = dfixed_const(1);
2080	if ((wm->vsc.full > a.full) ||
2081	    ((wm->vsc.full > b.full) && (wm->vtaps >= 3)) ||
2082	    (wm->vtaps >= 5) ||
2083	    ((wm->vsc.full >= a.full) && wm->interlaced))
2084		max_src_lines_per_dst_line = 4;
2085	else
2086		max_src_lines_per_dst_line = 2;
2087
2088	a.full = dfixed_const(available_bandwidth);
2089	b.full = dfixed_const(wm->num_heads);
2090	a.full = dfixed_div(a, b);
2091
2092	lb_fill_bw = min(dfixed_trunc(a), wm->disp_clk * wm->bytes_per_pixel / 1000);
 
 
 
 
 
 
2093
2094	a.full = dfixed_const(max_src_lines_per_dst_line * wm->src_width * wm->bytes_per_pixel);
2095	b.full = dfixed_const(1000);
2096	c.full = dfixed_const(lb_fill_bw);
2097	b.full = dfixed_div(c, b);
2098	a.full = dfixed_div(a, b);
2099	line_fill_time = dfixed_trunc(a);
2100
2101	if (line_fill_time < wm->active_time)
2102		return latency;
2103	else
2104		return latency + (line_fill_time - wm->active_time);
2105
2106}
2107
2108static bool evergreen_average_bandwidth_vs_dram_bandwidth_for_display(struct evergreen_wm_params *wm)
2109{
2110	if (evergreen_average_bandwidth(wm) <=
2111	    (evergreen_dram_bandwidth_for_display(wm) / wm->num_heads))
2112		return true;
2113	else
2114		return false;
2115};
2116
2117static bool evergreen_average_bandwidth_vs_available_bandwidth(struct evergreen_wm_params *wm)
2118{
2119	if (evergreen_average_bandwidth(wm) <=
2120	    (evergreen_available_bandwidth(wm) / wm->num_heads))
2121		return true;
2122	else
2123		return false;
2124};
2125
2126static bool evergreen_check_latency_hiding(struct evergreen_wm_params *wm)
2127{
2128	u32 lb_partitions = wm->lb_size / wm->src_width;
2129	u32 line_time = wm->active_time + wm->blank_time;
2130	u32 latency_tolerant_lines;
2131	u32 latency_hiding;
2132	fixed20_12 a;
2133
2134	a.full = dfixed_const(1);
2135	if (wm->vsc.full > a.full)
2136		latency_tolerant_lines = 1;
2137	else {
2138		if (lb_partitions <= (wm->vtaps + 1))
2139			latency_tolerant_lines = 1;
2140		else
2141			latency_tolerant_lines = 2;
2142	}
2143
2144	latency_hiding = (latency_tolerant_lines * line_time + wm->blank_time);
2145
2146	if (evergreen_latency_watermark(wm) <= latency_hiding)
2147		return true;
2148	else
2149		return false;
2150}
2151
2152static void evergreen_program_watermarks(struct radeon_device *rdev,
2153					 struct radeon_crtc *radeon_crtc,
2154					 u32 lb_size, u32 num_heads)
2155{
2156	struct drm_display_mode *mode = &radeon_crtc->base.mode;
2157	struct evergreen_wm_params wm_low, wm_high;
2158	u32 dram_channels;
2159	u32 active_time;
2160	u32 line_time = 0;
2161	u32 latency_watermark_a = 0, latency_watermark_b = 0;
2162	u32 priority_a_mark = 0, priority_b_mark = 0;
2163	u32 priority_a_cnt = PRIORITY_OFF;
2164	u32 priority_b_cnt = PRIORITY_OFF;
2165	u32 pipe_offset = radeon_crtc->crtc_id * 16;
2166	u32 tmp, arb_control3;
2167	fixed20_12 a, b, c;
2168
2169	if (radeon_crtc->base.enabled && num_heads && mode) {
2170		active_time = (u32) div_u64((u64)mode->crtc_hdisplay * 1000000,
2171					    (u32)mode->clock);
2172		line_time = (u32) div_u64((u64)mode->crtc_htotal * 1000000,
2173					  (u32)mode->clock);
2174		line_time = min(line_time, (u32)65535);
2175		priority_a_cnt = 0;
2176		priority_b_cnt = 0;
2177		dram_channels = evergreen_get_number_of_dram_channels(rdev);
2178
2179		/* watermark for high clocks */
2180		if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) {
2181			wm_high.yclk =
2182				radeon_dpm_get_mclk(rdev, false) * 10;
2183			wm_high.sclk =
2184				radeon_dpm_get_sclk(rdev, false) * 10;
2185		} else {
2186			wm_high.yclk = rdev->pm.current_mclk * 10;
2187			wm_high.sclk = rdev->pm.current_sclk * 10;
2188		}
2189
2190		wm_high.disp_clk = mode->clock;
2191		wm_high.src_width = mode->crtc_hdisplay;
2192		wm_high.active_time = active_time;
2193		wm_high.blank_time = line_time - wm_high.active_time;
2194		wm_high.interlaced = false;
2195		if (mode->flags & DRM_MODE_FLAG_INTERLACE)
2196			wm_high.interlaced = true;
2197		wm_high.vsc = radeon_crtc->vsc;
2198		wm_high.vtaps = 1;
2199		if (radeon_crtc->rmx_type != RMX_OFF)
2200			wm_high.vtaps = 2;
2201		wm_high.bytes_per_pixel = 4; /* XXX: get this from fb config */
2202		wm_high.lb_size = lb_size;
2203		wm_high.dram_channels = dram_channels;
2204		wm_high.num_heads = num_heads;
2205
2206		/* watermark for low clocks */
2207		if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) {
2208			wm_low.yclk =
2209				radeon_dpm_get_mclk(rdev, true) * 10;
2210			wm_low.sclk =
2211				radeon_dpm_get_sclk(rdev, true) * 10;
2212		} else {
2213			wm_low.yclk = rdev->pm.current_mclk * 10;
2214			wm_low.sclk = rdev->pm.current_sclk * 10;
2215		}
2216
2217		wm_low.disp_clk = mode->clock;
2218		wm_low.src_width = mode->crtc_hdisplay;
2219		wm_low.active_time = active_time;
2220		wm_low.blank_time = line_time - wm_low.active_time;
2221		wm_low.interlaced = false;
2222		if (mode->flags & DRM_MODE_FLAG_INTERLACE)
2223			wm_low.interlaced = true;
2224		wm_low.vsc = radeon_crtc->vsc;
2225		wm_low.vtaps = 1;
2226		if (radeon_crtc->rmx_type != RMX_OFF)
2227			wm_low.vtaps = 2;
2228		wm_low.bytes_per_pixel = 4; /* XXX: get this from fb config */
2229		wm_low.lb_size = lb_size;
2230		wm_low.dram_channels = dram_channels;
2231		wm_low.num_heads = num_heads;
2232
2233		/* set for high clocks */
2234		latency_watermark_a = min(evergreen_latency_watermark(&wm_high), (u32)65535);
2235		/* set for low clocks */
2236		latency_watermark_b = min(evergreen_latency_watermark(&wm_low), (u32)65535);
2237
2238		/* possibly force display priority to high */
2239		/* should really do this at mode validation time... */
2240		if (!evergreen_average_bandwidth_vs_dram_bandwidth_for_display(&wm_high) ||
2241		    !evergreen_average_bandwidth_vs_available_bandwidth(&wm_high) ||
2242		    !evergreen_check_latency_hiding(&wm_high) ||
2243		    (rdev->disp_priority == 2)) {
2244			DRM_DEBUG_KMS("force priority a to high\n");
2245			priority_a_cnt |= PRIORITY_ALWAYS_ON;
2246		}
2247		if (!evergreen_average_bandwidth_vs_dram_bandwidth_for_display(&wm_low) ||
2248		    !evergreen_average_bandwidth_vs_available_bandwidth(&wm_low) ||
2249		    !evergreen_check_latency_hiding(&wm_low) ||
2250		    (rdev->disp_priority == 2)) {
2251			DRM_DEBUG_KMS("force priority b to high\n");
2252			priority_b_cnt |= PRIORITY_ALWAYS_ON;
2253		}
2254
2255		a.full = dfixed_const(1000);
2256		b.full = dfixed_const(mode->clock);
2257		b.full = dfixed_div(b, a);
2258		c.full = dfixed_const(latency_watermark_a);
2259		c.full = dfixed_mul(c, b);
2260		c.full = dfixed_mul(c, radeon_crtc->hsc);
2261		c.full = dfixed_div(c, a);
2262		a.full = dfixed_const(16);
2263		c.full = dfixed_div(c, a);
2264		priority_a_mark = dfixed_trunc(c);
2265		priority_a_cnt |= priority_a_mark & PRIORITY_MARK_MASK;
2266
2267		a.full = dfixed_const(1000);
2268		b.full = dfixed_const(mode->clock);
2269		b.full = dfixed_div(b, a);
2270		c.full = dfixed_const(latency_watermark_b);
2271		c.full = dfixed_mul(c, b);
2272		c.full = dfixed_mul(c, radeon_crtc->hsc);
2273		c.full = dfixed_div(c, a);
2274		a.full = dfixed_const(16);
2275		c.full = dfixed_div(c, a);
2276		priority_b_mark = dfixed_trunc(c);
2277		priority_b_cnt |= priority_b_mark & PRIORITY_MARK_MASK;
2278
2279		/* Save number of lines the linebuffer leads before the scanout */
2280		radeon_crtc->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);
2281	}
2282
2283	/* select wm A */
2284	arb_control3 = RREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset);
2285	tmp = arb_control3;
2286	tmp &= ~LATENCY_WATERMARK_MASK(3);
2287	tmp |= LATENCY_WATERMARK_MASK(1);
2288	WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, tmp);
2289	WREG32(PIPE0_LATENCY_CONTROL + pipe_offset,
2290	       (LATENCY_LOW_WATERMARK(latency_watermark_a) |
2291		LATENCY_HIGH_WATERMARK(line_time)));
2292	/* select wm B */
2293	tmp = RREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset);
2294	tmp &= ~LATENCY_WATERMARK_MASK(3);
2295	tmp |= LATENCY_WATERMARK_MASK(2);
2296	WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, tmp);
2297	WREG32(PIPE0_LATENCY_CONTROL + pipe_offset,
2298	       (LATENCY_LOW_WATERMARK(latency_watermark_b) |
2299		LATENCY_HIGH_WATERMARK(line_time)));
2300	/* restore original selection */
2301	WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, arb_control3);
2302
2303	/* write the priority marks */
2304	WREG32(PRIORITY_A_CNT + radeon_crtc->crtc_offset, priority_a_cnt);
2305	WREG32(PRIORITY_B_CNT + radeon_crtc->crtc_offset, priority_b_cnt);
2306
2307	/* save values for DPM */
2308	radeon_crtc->line_time = line_time;
2309	radeon_crtc->wm_high = latency_watermark_a;
2310	radeon_crtc->wm_low = latency_watermark_b;
2311}
2312
2313/**
2314 * evergreen_bandwidth_update - update display watermarks callback.
2315 *
2316 * @rdev: radeon_device pointer
2317 *
2318 * Update the display watermarks based on the requested mode(s)
2319 * (evergreen+).
2320 */
2321void evergreen_bandwidth_update(struct radeon_device *rdev)
2322{
2323	struct drm_display_mode *mode0 = NULL;
2324	struct drm_display_mode *mode1 = NULL;
2325	u32 num_heads = 0, lb_size;
2326	int i;
2327
2328	if (!rdev->mode_info.mode_config_initialized)
2329		return;
2330
2331	radeon_update_display_priority(rdev);
2332
2333	for (i = 0; i < rdev->num_crtc; i++) {
2334		if (rdev->mode_info.crtcs[i]->base.enabled)
2335			num_heads++;
2336	}
2337	for (i = 0; i < rdev->num_crtc; i += 2) {
2338		mode0 = &rdev->mode_info.crtcs[i]->base.mode;
2339		mode1 = &rdev->mode_info.crtcs[i+1]->base.mode;
2340		lb_size = evergreen_line_buffer_adjust(rdev, rdev->mode_info.crtcs[i], mode0, mode1);
2341		evergreen_program_watermarks(rdev, rdev->mode_info.crtcs[i], lb_size, num_heads);
2342		lb_size = evergreen_line_buffer_adjust(rdev, rdev->mode_info.crtcs[i+1], mode1, mode0);
2343		evergreen_program_watermarks(rdev, rdev->mode_info.crtcs[i+1], lb_size, num_heads);
2344	}
2345}
2346
2347/**
2348 * evergreen_mc_wait_for_idle - wait for MC idle callback.
2349 *
2350 * @rdev: radeon_device pointer
2351 *
2352 * Wait for the MC (memory controller) to be idle.
2353 * (evergreen+).
2354 * Returns 0 if the MC is idle, -1 if not.
2355 */
2356int evergreen_mc_wait_for_idle(struct radeon_device *rdev)
2357{
2358	unsigned i;
2359	u32 tmp;
2360
2361	for (i = 0; i < rdev->usec_timeout; i++) {
2362		/* read MC_STATUS */
2363		tmp = RREG32(SRBM_STATUS) & 0x1F00;
2364		if (!tmp)
2365			return 0;
2366		udelay(1);
2367	}
2368	return -1;
2369}
2370
2371/*
2372 * GART
2373 */
2374void evergreen_pcie_gart_tlb_flush(struct radeon_device *rdev)
2375{
2376	unsigned i;
2377	u32 tmp;
2378
2379	WREG32(HDP_MEM_COHERENCY_FLUSH_CNTL, 0x1);
2380
2381	WREG32(VM_CONTEXT0_REQUEST_RESPONSE, REQUEST_TYPE(1));
2382	for (i = 0; i < rdev->usec_timeout; i++) {
2383		/* read MC_STATUS */
2384		tmp = RREG32(VM_CONTEXT0_REQUEST_RESPONSE);
2385		tmp = (tmp & RESPONSE_TYPE_MASK) >> RESPONSE_TYPE_SHIFT;
2386		if (tmp == 2) {
2387			pr_warn("[drm] r600 flush TLB failed\n");
2388			return;
2389		}
2390		if (tmp) {
2391			return;
2392		}
2393		udelay(1);
2394	}
2395}
2396
2397static int evergreen_pcie_gart_enable(struct radeon_device *rdev)
2398{
2399	u32 tmp;
2400	int r;
2401
2402	if (rdev->gart.robj == NULL) {
2403		dev_err(rdev->dev, "No VRAM object for PCIE GART.\n");
2404		return -EINVAL;
2405	}
2406	r = radeon_gart_table_vram_pin(rdev);
2407	if (r)
2408		return r;
2409	/* Setup L2 cache */
2410	WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING |
2411				ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE |
2412				EFFECTIVE_L2_QUEUE_SIZE(7));
2413	WREG32(VM_L2_CNTL2, 0);
2414	WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
2415	/* Setup TLB control */
2416	tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING |
2417		SYSTEM_ACCESS_MODE_NOT_IN_SYS |
2418		SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU |
2419		EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
2420	if (rdev->flags & RADEON_IS_IGP) {
2421		WREG32(FUS_MC_VM_MD_L1_TLB0_CNTL, tmp);
2422		WREG32(FUS_MC_VM_MD_L1_TLB1_CNTL, tmp);
2423		WREG32(FUS_MC_VM_MD_L1_TLB2_CNTL, tmp);
2424	} else {
2425		WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
2426		WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
2427		WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
2428		if ((rdev->family == CHIP_JUNIPER) ||
2429		    (rdev->family == CHIP_CYPRESS) ||
2430		    (rdev->family == CHIP_HEMLOCK) ||
2431		    (rdev->family == CHIP_BARTS))
2432			WREG32(MC_VM_MD_L1_TLB3_CNTL, tmp);
2433	}
2434	WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
2435	WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
2436	WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
2437	WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
2438	WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12);
2439	WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, rdev->mc.gtt_end >> 12);
2440	WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12);
2441	WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) |
2442				RANGE_PROTECTION_FAULT_ENABLE_DEFAULT);
2443	WREG32(VM_CONTEXT0_PROTECTION_FAULT_DEFAULT_ADDR,
2444			(u32)(rdev->dummy_page.addr >> 12));
2445	WREG32(VM_CONTEXT1_CNTL, 0);
2446
2447	evergreen_pcie_gart_tlb_flush(rdev);
2448	DRM_INFO("PCIE GART of %uM enabled (table at 0x%016llX).\n",
2449		 (unsigned)(rdev->mc.gtt_size >> 20),
2450		 (unsigned long long)rdev->gart.table_addr);
2451	rdev->gart.ready = true;
2452	return 0;
2453}
2454
2455static void evergreen_pcie_gart_disable(struct radeon_device *rdev)
2456{
2457	u32 tmp;
2458
2459	/* Disable all tables */
2460	WREG32(VM_CONTEXT0_CNTL, 0);
2461	WREG32(VM_CONTEXT1_CNTL, 0);
2462
2463	/* Setup L2 cache */
2464	WREG32(VM_L2_CNTL, ENABLE_L2_FRAGMENT_PROCESSING |
2465				EFFECTIVE_L2_QUEUE_SIZE(7));
2466	WREG32(VM_L2_CNTL2, 0);
2467	WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
2468	/* Setup TLB control */
2469	tmp = EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
2470	WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
2471	WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
2472	WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
2473	WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
2474	WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
2475	WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
2476	WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
2477	radeon_gart_table_vram_unpin(rdev);
2478}
2479
2480static void evergreen_pcie_gart_fini(struct radeon_device *rdev)
2481{
2482	evergreen_pcie_gart_disable(rdev);
2483	radeon_gart_table_vram_free(rdev);
2484	radeon_gart_fini(rdev);
2485}
2486
2487
2488static void evergreen_agp_enable(struct radeon_device *rdev)
2489{
2490	u32 tmp;
2491
2492	/* Setup L2 cache */
2493	WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING |
2494				ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE |
2495				EFFECTIVE_L2_QUEUE_SIZE(7));
2496	WREG32(VM_L2_CNTL2, 0);
2497	WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
2498	/* Setup TLB control */
2499	tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING |
2500		SYSTEM_ACCESS_MODE_NOT_IN_SYS |
2501		SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU |
2502		EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
2503	WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
2504	WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
2505	WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
2506	WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
2507	WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
2508	WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
2509	WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
2510	WREG32(VM_CONTEXT0_CNTL, 0);
2511	WREG32(VM_CONTEXT1_CNTL, 0);
2512}
2513
2514static const unsigned ni_dig_offsets[] =
2515{
2516	NI_DIG0_REGISTER_OFFSET,
2517	NI_DIG1_REGISTER_OFFSET,
2518	NI_DIG2_REGISTER_OFFSET,
2519	NI_DIG3_REGISTER_OFFSET,
2520	NI_DIG4_REGISTER_OFFSET,
2521	NI_DIG5_REGISTER_OFFSET
2522};
2523
2524static const unsigned ni_tx_offsets[] =
2525{
2526	NI_DCIO_UNIPHY0_UNIPHY_TX_CONTROL1,
2527	NI_DCIO_UNIPHY1_UNIPHY_TX_CONTROL1,
2528	NI_DCIO_UNIPHY2_UNIPHY_TX_CONTROL1,
2529	NI_DCIO_UNIPHY3_UNIPHY_TX_CONTROL1,
2530	NI_DCIO_UNIPHY4_UNIPHY_TX_CONTROL1,
2531	NI_DCIO_UNIPHY5_UNIPHY_TX_CONTROL1
2532};
2533
2534static const unsigned evergreen_dp_offsets[] =
2535{
2536	EVERGREEN_DP0_REGISTER_OFFSET,
2537	EVERGREEN_DP1_REGISTER_OFFSET,
2538	EVERGREEN_DP2_REGISTER_OFFSET,
2539	EVERGREEN_DP3_REGISTER_OFFSET,
2540	EVERGREEN_DP4_REGISTER_OFFSET,
2541	EVERGREEN_DP5_REGISTER_OFFSET
2542};
2543
2544static const unsigned evergreen_disp_int_status[] =
2545{
2546	DISP_INTERRUPT_STATUS,
2547	DISP_INTERRUPT_STATUS_CONTINUE,
2548	DISP_INTERRUPT_STATUS_CONTINUE2,
2549	DISP_INTERRUPT_STATUS_CONTINUE3,
2550	DISP_INTERRUPT_STATUS_CONTINUE4,
2551	DISP_INTERRUPT_STATUS_CONTINUE5
2552};
2553
2554/*
2555 * Assumption is that EVERGREEN_CRTC_MASTER_EN enable for requested crtc
2556 * We go from crtc to connector and it is not relible  since it
2557 * should be an opposite direction .If crtc is enable then
2558 * find the dig_fe which selects this crtc and insure that it enable.
2559 * if such dig_fe is found then find dig_be which selects found dig_be and
2560 * insure that it enable and in DP_SST mode.
2561 * if UNIPHY_PLL_CONTROL1.enable then we should disconnect timing
2562 * from dp symbols clocks .
2563 */
2564static bool evergreen_is_dp_sst_stream_enabled(struct radeon_device *rdev,
2565					       unsigned crtc_id, unsigned *ret_dig_fe)
2566{
2567	unsigned i;
2568	unsigned dig_fe;
2569	unsigned dig_be;
2570	unsigned dig_en_be;
2571	unsigned uniphy_pll;
2572	unsigned digs_fe_selected;
2573	unsigned dig_be_mode;
2574	unsigned dig_fe_mask;
2575	bool is_enabled = false;
2576	bool found_crtc = false;
2577
2578	/* loop through all running dig_fe to find selected crtc */
2579	for (i = 0; i < ARRAY_SIZE(ni_dig_offsets); i++) {
2580		dig_fe = RREG32(NI_DIG_FE_CNTL + ni_dig_offsets[i]);
2581		if (dig_fe & NI_DIG_FE_CNTL_SYMCLK_FE_ON &&
2582		    crtc_id == NI_DIG_FE_CNTL_SOURCE_SELECT(dig_fe)) {
2583			/* found running pipe */
2584			found_crtc = true;
2585			dig_fe_mask = 1 << i;
2586			dig_fe = i;
2587			break;
2588		}
2589	}
2590
2591	if (found_crtc) {
2592		/* loop through all running dig_be to find selected dig_fe */
2593		for (i = 0; i < ARRAY_SIZE(ni_dig_offsets); i++) {
2594			dig_be = RREG32(NI_DIG_BE_CNTL + ni_dig_offsets[i]);
2595			/* if dig_fe_selected by dig_be? */
2596			digs_fe_selected = NI_DIG_BE_CNTL_FE_SOURCE_SELECT(dig_be);
2597			dig_be_mode = NI_DIG_FE_CNTL_MODE(dig_be);
2598			if (dig_fe_mask &  digs_fe_selected &&
2599			    /* if dig_be in sst mode? */
2600			    dig_be_mode == NI_DIG_BE_DPSST) {
2601				dig_en_be = RREG32(NI_DIG_BE_EN_CNTL +
2602						   ni_dig_offsets[i]);
2603				uniphy_pll = RREG32(NI_DCIO_UNIPHY0_PLL_CONTROL1 +
2604						    ni_tx_offsets[i]);
2605				/* dig_be enable and tx is running */
2606				if (dig_en_be & NI_DIG_BE_EN_CNTL_ENABLE &&
2607				    dig_en_be & NI_DIG_BE_EN_CNTL_SYMBCLK_ON &&
2608				    uniphy_pll & NI_DCIO_UNIPHY0_PLL_CONTROL1_ENABLE) {
2609					is_enabled = true;
2610					*ret_dig_fe = dig_fe;
2611					break;
2612				}
2613			}
2614		}
2615	}
2616
2617	return is_enabled;
2618}
2619
2620/*
2621 * Blank dig when in dp sst mode
2622 * Dig ignores crtc timing
2623 */
2624static void evergreen_blank_dp_output(struct radeon_device *rdev,
2625				      unsigned dig_fe)
2626{
2627	unsigned stream_ctrl;
2628	unsigned fifo_ctrl;
2629	unsigned counter = 0;
2630
2631	if (dig_fe >= ARRAY_SIZE(evergreen_dp_offsets)) {
2632		DRM_ERROR("invalid dig_fe %d\n", dig_fe);
2633		return;
2634	}
2635
2636	stream_ctrl = RREG32(EVERGREEN_DP_VID_STREAM_CNTL +
2637			     evergreen_dp_offsets[dig_fe]);
2638	if (!(stream_ctrl & EVERGREEN_DP_VID_STREAM_CNTL_ENABLE)) {
2639		DRM_ERROR("dig %d , should be enable\n", dig_fe);
2640		return;
2641	}
2642
2643	stream_ctrl &=~EVERGREEN_DP_VID_STREAM_CNTL_ENABLE;
2644	WREG32(EVERGREEN_DP_VID_STREAM_CNTL +
2645	       evergreen_dp_offsets[dig_fe], stream_ctrl);
2646
2647	stream_ctrl = RREG32(EVERGREEN_DP_VID_STREAM_CNTL +
2648			     evergreen_dp_offsets[dig_fe]);
2649	while (counter < 32 && stream_ctrl & EVERGREEN_DP_VID_STREAM_STATUS) {
2650		msleep(1);
2651		counter++;
2652		stream_ctrl = RREG32(EVERGREEN_DP_VID_STREAM_CNTL +
2653				     evergreen_dp_offsets[dig_fe]);
2654	}
2655	if (counter >= 32 )
2656		DRM_ERROR("counter exceeds %d\n", counter);
2657
2658	fifo_ctrl = RREG32(EVERGREEN_DP_STEER_FIFO + evergreen_dp_offsets[dig_fe]);
2659	fifo_ctrl |= EVERGREEN_DP_STEER_FIFO_RESET;
2660	WREG32(EVERGREEN_DP_STEER_FIFO + evergreen_dp_offsets[dig_fe], fifo_ctrl);
2661
2662}
2663
2664void evergreen_mc_stop(struct radeon_device *rdev, struct evergreen_mc_save *save)
2665{
2666	u32 crtc_enabled, tmp, frame_count, blackout;
2667	int i, j;
2668	unsigned dig_fe;
2669
2670	if (!ASIC_IS_NODCE(rdev)) {
2671		save->vga_render_control = RREG32(VGA_RENDER_CONTROL);
2672		save->vga_hdp_control = RREG32(VGA_HDP_CONTROL);
2673
2674		/* disable VGA render */
2675		WREG32(VGA_RENDER_CONTROL, 0);
2676	}
2677	/* blank the display controllers */
2678	for (i = 0; i < rdev->num_crtc; i++) {
2679		crtc_enabled = RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i]) & EVERGREEN_CRTC_MASTER_EN;
2680		if (crtc_enabled) {
2681			save->crtc_enabled[i] = true;
2682			if (ASIC_IS_DCE6(rdev)) {
2683				tmp = RREG32(EVERGREEN_CRTC_BLANK_CONTROL + crtc_offsets[i]);
2684				if (!(tmp & EVERGREEN_CRTC_BLANK_DATA_EN)) {
2685					radeon_wait_for_vblank(rdev, i);
2686					WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 1);
2687					tmp |= EVERGREEN_CRTC_BLANK_DATA_EN;
2688					WREG32(EVERGREEN_CRTC_BLANK_CONTROL + crtc_offsets[i], tmp);
2689					WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 0);
2690				}
2691			} else {
2692				tmp = RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i]);
2693				if (!(tmp & EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE)) {
2694					radeon_wait_for_vblank(rdev, i);
2695					WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 1);
2696					tmp |= EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE;
2697					WREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i], tmp);
2698					WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 0);
2699				}
2700			}
2701			/* wait for the next frame */
2702			frame_count = radeon_get_vblank_counter(rdev, i);
2703			for (j = 0; j < rdev->usec_timeout; j++) {
2704				if (radeon_get_vblank_counter(rdev, i) != frame_count)
2705					break;
2706				udelay(1);
2707			}
2708			/*we should disable dig if it drives dp sst*/
2709			/*but we are in radeon_device_init and the topology is unknown*/
2710			/*and it is available after radeon_modeset_init*/
2711			/*the following method radeon_atom_encoder_dpms_dig*/
2712			/*does the job if we initialize it properly*/
2713			/*for now we do it this manually*/
2714			/**/
2715			if (ASIC_IS_DCE5(rdev) &&
2716			    evergreen_is_dp_sst_stream_enabled(rdev, i ,&dig_fe))
2717				evergreen_blank_dp_output(rdev, dig_fe);
2718			/*we could remove 6 lines below*/
2719			/* XXX this is a hack to avoid strange behavior with EFI on certain systems */
2720			WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 1);
2721			tmp = RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i]);
2722			tmp &= ~EVERGREEN_CRTC_MASTER_EN;
2723			WREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i], tmp);
2724			WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 0);
2725			save->crtc_enabled[i] = false;
2726			/* ***** */
2727		} else {
2728			save->crtc_enabled[i] = false;
2729		}
2730	}
2731
2732	radeon_mc_wait_for_idle(rdev);
2733
2734	blackout = RREG32(MC_SHARED_BLACKOUT_CNTL);
2735	if ((blackout & BLACKOUT_MODE_MASK) != 1) {
2736		/* Block CPU access */
2737		WREG32(BIF_FB_EN, 0);
2738		/* blackout the MC */
2739		blackout &= ~BLACKOUT_MODE_MASK;
2740		WREG32(MC_SHARED_BLACKOUT_CNTL, blackout | 1);
2741	}
2742	/* wait for the MC to settle */
2743	udelay(100);
2744
2745	/* lock double buffered regs */
2746	for (i = 0; i < rdev->num_crtc; i++) {
2747		if (save->crtc_enabled[i]) {
2748			tmp = RREG32(EVERGREEN_GRPH_UPDATE + crtc_offsets[i]);
2749			if (!(tmp & EVERGREEN_GRPH_UPDATE_LOCK)) {
2750				tmp |= EVERGREEN_GRPH_UPDATE_LOCK;
2751				WREG32(EVERGREEN_GRPH_UPDATE + crtc_offsets[i], tmp);
2752			}
2753			tmp = RREG32(EVERGREEN_MASTER_UPDATE_LOCK + crtc_offsets[i]);
2754			if (!(tmp & 1)) {
2755				tmp |= 1;
2756				WREG32(EVERGREEN_MASTER_UPDATE_LOCK + crtc_offsets[i], tmp);
2757			}
2758		}
2759	}
2760}
2761
2762void evergreen_mc_resume(struct radeon_device *rdev, struct evergreen_mc_save *save)
2763{
2764	u32 tmp, frame_count;
2765	int i, j;
2766
2767	/* update crtc base addresses */
2768	for (i = 0; i < rdev->num_crtc; i++) {
2769		WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS_HIGH + crtc_offsets[i],
2770		       upper_32_bits(rdev->mc.vram_start));
2771		WREG32(EVERGREEN_GRPH_SECONDARY_SURFACE_ADDRESS_HIGH + crtc_offsets[i],
2772		       upper_32_bits(rdev->mc.vram_start));
2773		WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS + crtc_offsets[i],
2774		       (u32)rdev->mc.vram_start);
2775		WREG32(EVERGREEN_GRPH_SECONDARY_SURFACE_ADDRESS + crtc_offsets[i],
2776		       (u32)rdev->mc.vram_start);
2777	}
2778
2779	if (!ASIC_IS_NODCE(rdev)) {
2780		WREG32(EVERGREEN_VGA_MEMORY_BASE_ADDRESS_HIGH, upper_32_bits(rdev->mc.vram_start));
2781		WREG32(EVERGREEN_VGA_MEMORY_BASE_ADDRESS, (u32)rdev->mc.vram_start);
2782	}
2783
2784	/* unlock regs and wait for update */
2785	for (i = 0; i < rdev->num_crtc; i++) {
2786		if (save->crtc_enabled[i]) {
2787			tmp = RREG32(EVERGREEN_MASTER_UPDATE_MODE + crtc_offsets[i]);
2788			if ((tmp & 0x7) != 0) {
2789				tmp &= ~0x7;
2790				WREG32(EVERGREEN_MASTER_UPDATE_MODE + crtc_offsets[i], tmp);
2791			}
2792			tmp = RREG32(EVERGREEN_GRPH_UPDATE + crtc_offsets[i]);
2793			if (tmp & EVERGREEN_GRPH_UPDATE_LOCK) {
2794				tmp &= ~EVERGREEN_GRPH_UPDATE_LOCK;
2795				WREG32(EVERGREEN_GRPH_UPDATE + crtc_offsets[i], tmp);
2796			}
2797			tmp = RREG32(EVERGREEN_MASTER_UPDATE_LOCK + crtc_offsets[i]);
2798			if (tmp & 1) {
2799				tmp &= ~1;
2800				WREG32(EVERGREEN_MASTER_UPDATE_LOCK + crtc_offsets[i], tmp);
2801			}
2802			for (j = 0; j < rdev->usec_timeout; j++) {
2803				tmp = RREG32(EVERGREEN_GRPH_UPDATE + crtc_offsets[i]);
2804				if ((tmp & EVERGREEN_GRPH_SURFACE_UPDATE_PENDING) == 0)
2805					break;
2806				udelay(1);
2807			}
2808		}
2809	}
2810
2811	/* unblackout the MC */
2812	tmp = RREG32(MC_SHARED_BLACKOUT_CNTL);
2813	tmp &= ~BLACKOUT_MODE_MASK;
2814	WREG32(MC_SHARED_BLACKOUT_CNTL, tmp);
2815	/* allow CPU access */
2816	WREG32(BIF_FB_EN, FB_READ_EN | FB_WRITE_EN);
2817
2818	for (i = 0; i < rdev->num_crtc; i++) {
2819		if (save->crtc_enabled[i]) {
2820			if (ASIC_IS_DCE6(rdev)) {
2821				tmp = RREG32(EVERGREEN_CRTC_BLANK_CONTROL + crtc_offsets[i]);
2822				tmp &= ~EVERGREEN_CRTC_BLANK_DATA_EN;
2823				WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 1);
2824				WREG32(EVERGREEN_CRTC_BLANK_CONTROL + crtc_offsets[i], tmp);
2825				WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 0);
2826			} else {
2827				tmp = RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i]);
2828				tmp &= ~EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE;
2829				WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 1);
2830				WREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i], tmp);
2831				WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 0);
2832			}
2833			/* wait for the next frame */
2834			frame_count = radeon_get_vblank_counter(rdev, i);
2835			for (j = 0; j < rdev->usec_timeout; j++) {
2836				if (radeon_get_vblank_counter(rdev, i) != frame_count)
2837					break;
2838				udelay(1);
2839			}
2840		}
2841	}
2842	if (!ASIC_IS_NODCE(rdev)) {
2843		/* Unlock vga access */
2844		WREG32(VGA_HDP_CONTROL, save->vga_hdp_control);
2845		mdelay(1);
2846		WREG32(VGA_RENDER_CONTROL, save->vga_render_control);
2847	}
2848}
2849
2850void evergreen_mc_program(struct radeon_device *rdev)
2851{
2852	struct evergreen_mc_save save;
2853	u32 tmp;
2854	int i, j;
2855
2856	/* Initialize HDP */
2857	for (i = 0, j = 0; i < 32; i++, j += 0x18) {
2858		WREG32((0x2c14 + j), 0x00000000);
2859		WREG32((0x2c18 + j), 0x00000000);
2860		WREG32((0x2c1c + j), 0x00000000);
2861		WREG32((0x2c20 + j), 0x00000000);
2862		WREG32((0x2c24 + j), 0x00000000);
2863	}
2864	WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0);
2865
2866	evergreen_mc_stop(rdev, &save);
2867	if (evergreen_mc_wait_for_idle(rdev)) {
2868		dev_warn(rdev->dev, "Wait for MC idle timedout !\n");
2869	}
2870	/* Lockout access through VGA aperture*/
2871	WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE);
2872	/* Update configuration */
2873	if (rdev->flags & RADEON_IS_AGP) {
2874		if (rdev->mc.vram_start < rdev->mc.gtt_start) {
2875			/* VRAM before AGP */
2876			WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR,
2877				rdev->mc.vram_start >> 12);
2878			WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR,
2879				rdev->mc.gtt_end >> 12);
2880		} else {
2881			/* VRAM after AGP */
2882			WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR,
2883				rdev->mc.gtt_start >> 12);
2884			WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR,
2885				rdev->mc.vram_end >> 12);
2886		}
2887	} else {
2888		WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR,
2889			rdev->mc.vram_start >> 12);
2890		WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR,
2891			rdev->mc.vram_end >> 12);
2892	}
2893	WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, rdev->vram_scratch.gpu_addr >> 12);
2894	/* llano/ontario only */
2895	if ((rdev->family == CHIP_PALM) ||
2896	    (rdev->family == CHIP_SUMO) ||
2897	    (rdev->family == CHIP_SUMO2)) {
2898		tmp = RREG32(MC_FUS_VM_FB_OFFSET) & 0x000FFFFF;
2899		tmp |= ((rdev->mc.vram_end >> 20) & 0xF) << 24;
2900		tmp |= ((rdev->mc.vram_start >> 20) & 0xF) << 20;
2901		WREG32(MC_FUS_VM_FB_OFFSET, tmp);
2902	}
2903	tmp = ((rdev->mc.vram_end >> 24) & 0xFFFF) << 16;
2904	tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF);
2905	WREG32(MC_VM_FB_LOCATION, tmp);
2906	WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8));
2907	WREG32(HDP_NONSURFACE_INFO, (2 << 7) | (1 << 30));
2908	WREG32(HDP_NONSURFACE_SIZE, 0x3FFFFFFF);
2909	if (rdev->flags & RADEON_IS_AGP) {
2910		WREG32(MC_VM_AGP_TOP, rdev->mc.gtt_end >> 16);
2911		WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16);
2912		WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22);
2913	} else {
2914		WREG32(MC_VM_AGP_BASE, 0);
2915		WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF);
2916		WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF);
2917	}
2918	if (evergreen_mc_wait_for_idle(rdev)) {
2919		dev_warn(rdev->dev, "Wait for MC idle timedout !\n");
2920	}
2921	evergreen_mc_resume(rdev, &save);
2922	/* we need to own VRAM, so turn off the VGA renderer here
2923	 * to stop it overwriting our objects */
2924	rv515_vga_render_disable(rdev);
2925}
2926
2927/*
2928 * CP.
2929 */
2930void evergreen_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib)
2931{
2932	struct radeon_ring *ring = &rdev->ring[ib->ring];
2933	u32 next_rptr;
2934
2935	/* set to DX10/11 mode */
2936	radeon_ring_write(ring, PACKET3(PACKET3_MODE_CONTROL, 0));
2937	radeon_ring_write(ring, 1);
2938
2939	if (ring->rptr_save_reg) {
2940		next_rptr = ring->wptr + 3 + 4;
2941		radeon_ring_write(ring, PACKET3(PACKET3_SET_CONFIG_REG, 1));
2942		radeon_ring_write(ring, ((ring->rptr_save_reg - 
2943					  PACKET3_SET_CONFIG_REG_START) >> 2));
2944		radeon_ring_write(ring, next_rptr);
2945	} else if (rdev->wb.enabled) {
2946		next_rptr = ring->wptr + 5 + 4;
2947		radeon_ring_write(ring, PACKET3(PACKET3_MEM_WRITE, 3));
2948		radeon_ring_write(ring, ring->next_rptr_gpu_addr & 0xfffffffc);
2949		radeon_ring_write(ring, (upper_32_bits(ring->next_rptr_gpu_addr) & 0xff) | (1 << 18));
2950		radeon_ring_write(ring, next_rptr);
2951		radeon_ring_write(ring, 0);
2952	}
2953
2954	radeon_ring_write(ring, PACKET3(PACKET3_INDIRECT_BUFFER, 2));
2955	radeon_ring_write(ring,
2956#ifdef __BIG_ENDIAN
2957			  (2 << 0) |
2958#endif
2959			  (ib->gpu_addr & 0xFFFFFFFC));
2960	radeon_ring_write(ring, upper_32_bits(ib->gpu_addr) & 0xFF);
2961	radeon_ring_write(ring, ib->length_dw);
2962}
2963
2964
2965static int evergreen_cp_load_microcode(struct radeon_device *rdev)
2966{
2967	const __be32 *fw_data;
2968	int i;
2969
2970	if (!rdev->me_fw || !rdev->pfp_fw)
2971		return -EINVAL;
2972
2973	r700_cp_stop(rdev);
2974	WREG32(CP_RB_CNTL,
2975#ifdef __BIG_ENDIAN
2976	       BUF_SWAP_32BIT |
2977#endif
2978	       RB_NO_UPDATE | RB_BLKSZ(15) | RB_BUFSZ(3));
2979
2980	fw_data = (const __be32 *)rdev->pfp_fw->data;
2981	WREG32(CP_PFP_UCODE_ADDR, 0);
2982	for (i = 0; i < EVERGREEN_PFP_UCODE_SIZE; i++)
2983		WREG32(CP_PFP_UCODE_DATA, be32_to_cpup(fw_data++));
2984	WREG32(CP_PFP_UCODE_ADDR, 0);
2985
2986	fw_data = (const __be32 *)rdev->me_fw->data;
2987	WREG32(CP_ME_RAM_WADDR, 0);
2988	for (i = 0; i < EVERGREEN_PM4_UCODE_SIZE; i++)
2989		WREG32(CP_ME_RAM_DATA, be32_to_cpup(fw_data++));
2990
2991	WREG32(CP_PFP_UCODE_ADDR, 0);
2992	WREG32(CP_ME_RAM_WADDR, 0);
2993	WREG32(CP_ME_RAM_RADDR, 0);
2994	return 0;
2995}
2996
2997static int evergreen_cp_start(struct radeon_device *rdev)
2998{
2999	struct radeon_ring *ring = &rdev->ring[RADEON_RING_TYPE_GFX_INDEX];
3000	int r, i;
3001	uint32_t cp_me;
3002
3003	r = radeon_ring_lock(rdev, ring, 7);
3004	if (r) {
3005		DRM_ERROR("radeon: cp failed to lock ring (%d).\n", r);
3006		return r;
3007	}
3008	radeon_ring_write(ring, PACKET3(PACKET3_ME_INITIALIZE, 5));
3009	radeon_ring_write(ring, 0x1);
3010	radeon_ring_write(ring, 0x0);
3011	radeon_ring_write(ring, rdev->config.evergreen.max_hw_contexts - 1);
3012	radeon_ring_write(ring, PACKET3_ME_INITIALIZE_DEVICE_ID(1));
3013	radeon_ring_write(ring, 0);
3014	radeon_ring_write(ring, 0);
3015	radeon_ring_unlock_commit(rdev, ring, false);
3016
3017	cp_me = 0xff;
3018	WREG32(CP_ME_CNTL, cp_me);
3019
3020	r = radeon_ring_lock(rdev, ring, evergreen_default_size + 19);
3021	if (r) {
3022		DRM_ERROR("radeon: cp failed to lock ring (%d).\n", r);
3023		return r;
3024	}
3025
3026	/* setup clear context state */
3027	radeon_ring_write(ring, PACKET3(PACKET3_PREAMBLE_CNTL, 0));
3028	radeon_ring_write(ring, PACKET3_PREAMBLE_BEGIN_CLEAR_STATE);
3029
3030	for (i = 0; i < evergreen_default_size; i++)
3031		radeon_ring_write(ring, evergreen_default_state[i]);
3032
3033	radeon_ring_write(ring, PACKET3(PACKET3_PREAMBLE_CNTL, 0));
3034	radeon_ring_write(ring, PACKET3_PREAMBLE_END_CLEAR_STATE);
3035
3036	/* set clear context state */
3037	radeon_ring_write(ring, PACKET3(PACKET3_CLEAR_STATE, 0));
3038	radeon_ring_write(ring, 0);
3039
3040	/* SQ_VTX_BASE_VTX_LOC */
3041	radeon_ring_write(ring, 0xc0026f00);
3042	radeon_ring_write(ring, 0x00000000);
3043	radeon_ring_write(ring, 0x00000000);
3044	radeon_ring_write(ring, 0x00000000);
3045
3046	/* Clear consts */
3047	radeon_ring_write(ring, 0xc0036f00);
3048	radeon_ring_write(ring, 0x00000bc4);
3049	radeon_ring_write(ring, 0xffffffff);
3050	radeon_ring_write(ring, 0xffffffff);
3051	radeon_ring_write(ring, 0xffffffff);
3052
3053	radeon_ring_write(ring, 0xc0026900);
3054	radeon_ring_write(ring, 0x00000316);
3055	radeon_ring_write(ring, 0x0000000e); /* VGT_VERTEX_REUSE_BLOCK_CNTL */
3056	radeon_ring_write(ring, 0x00000010); /*  */
3057
3058	radeon_ring_unlock_commit(rdev, ring, false);
3059
3060	return 0;
3061}
3062
3063static int evergreen_cp_resume(struct radeon_device *rdev)
3064{
3065	struct radeon_ring *ring = &rdev->ring[RADEON_RING_TYPE_GFX_INDEX];
3066	u32 tmp;
3067	u32 rb_bufsz;
3068	int r;
3069
3070	/* Reset cp; if cp is reset, then PA, SH, VGT also need to be reset */
3071	WREG32(GRBM_SOFT_RESET, (SOFT_RESET_CP |
3072				 SOFT_RESET_PA |
3073				 SOFT_RESET_SH |
3074				 SOFT_RESET_VGT |
3075				 SOFT_RESET_SPI |
3076				 SOFT_RESET_SX));
3077	RREG32(GRBM_SOFT_RESET);
3078	mdelay(15);
3079	WREG32(GRBM_SOFT_RESET, 0);
3080	RREG32(GRBM_SOFT_RESET);
3081
3082	/* Set ring buffer size */
3083	rb_bufsz = order_base_2(ring->ring_size / 8);
3084	tmp = (order_base_2(RADEON_GPU_PAGE_SIZE/8) << 8) | rb_bufsz;
3085#ifdef __BIG_ENDIAN
3086	tmp |= BUF_SWAP_32BIT;
3087#endif
3088	WREG32(CP_RB_CNTL, tmp);
3089	WREG32(CP_SEM_WAIT_TIMER, 0x0);
3090	WREG32(CP_SEM_INCOMPLETE_TIMER_CNTL, 0x0);
3091
3092	/* Set the write pointer delay */
3093	WREG32(CP_RB_WPTR_DELAY, 0);
3094
3095	/* Initialize the ring buffer's read and write pointers */
3096	WREG32(CP_RB_CNTL, tmp | RB_RPTR_WR_ENA);
3097	WREG32(CP_RB_RPTR_WR, 0);
3098	ring->wptr = 0;
3099	WREG32(CP_RB_WPTR, ring->wptr);
3100
3101	/* set the wb address whether it's enabled or not */
3102	WREG32(CP_RB_RPTR_ADDR,
3103	       ((rdev->wb.gpu_addr + RADEON_WB_CP_RPTR_OFFSET) & 0xFFFFFFFC));
3104	WREG32(CP_RB_RPTR_ADDR_HI, upper_32_bits(rdev->wb.gpu_addr + RADEON_WB_CP_RPTR_OFFSET) & 0xFF);
3105	WREG32(SCRATCH_ADDR, ((rdev->wb.gpu_addr + RADEON_WB_SCRATCH_OFFSET) >> 8) & 0xFFFFFFFF);
3106
3107	if (rdev->wb.enabled)
3108		WREG32(SCRATCH_UMSK, 0xff);
3109	else {
3110		tmp |= RB_NO_UPDATE;
3111		WREG32(SCRATCH_UMSK, 0);
3112	}
3113
3114	mdelay(1);
3115	WREG32(CP_RB_CNTL, tmp);
3116
3117	WREG32(CP_RB_BASE, ring->gpu_addr >> 8);
3118	WREG32(CP_DEBUG, (1 << 27) | (1 << 28));
3119
3120	evergreen_cp_start(rdev);
3121	ring->ready = true;
3122	r = radeon_ring_test(rdev, RADEON_RING_TYPE_GFX_INDEX, ring);
3123	if (r) {
3124		ring->ready = false;
3125		return r;
3126	}
3127	return 0;
3128}
3129
3130/*
3131 * Core functions
3132 */
3133static void evergreen_gpu_init(struct radeon_device *rdev)
3134{
3135	u32 gb_addr_config;
3136	u32 mc_shared_chmap, mc_arb_ramcfg;
3137	u32 sx_debug_1;
3138	u32 smx_dc_ctl0;
3139	u32 sq_config;
3140	u32 sq_lds_resource_mgmt;
3141	u32 sq_gpr_resource_mgmt_1;
3142	u32 sq_gpr_resource_mgmt_2;
3143	u32 sq_gpr_resource_mgmt_3;
3144	u32 sq_thread_resource_mgmt;
3145	u32 sq_thread_resource_mgmt_2;
3146	u32 sq_stack_resource_mgmt_1;
3147	u32 sq_stack_resource_mgmt_2;
3148	u32 sq_stack_resource_mgmt_3;
3149	u32 vgt_cache_invalidation;
3150	u32 hdp_host_path_cntl, tmp;
3151	u32 disabled_rb_mask;
3152	int i, j, ps_thread_count;
3153
3154	switch (rdev->family) {
3155	case CHIP_CYPRESS:
3156	case CHIP_HEMLOCK:
3157		rdev->config.evergreen.num_ses = 2;
3158		rdev->config.evergreen.max_pipes = 4;
3159		rdev->config.evergreen.max_tile_pipes = 8;
3160		rdev->config.evergreen.max_simds = 10;
3161		rdev->config.evergreen.max_backends = 4 * rdev->config.evergreen.num_ses;
3162		rdev->config.evergreen.max_gprs = 256;
3163		rdev->config.evergreen.max_threads = 248;
3164		rdev->config.evergreen.max_gs_threads = 32;
3165		rdev->config.evergreen.max_stack_entries = 512;
3166		rdev->config.evergreen.sx_num_of_sets = 4;
3167		rdev->config.evergreen.sx_max_export_size = 256;
3168		rdev->config.evergreen.sx_max_export_pos_size = 64;
3169		rdev->config.evergreen.sx_max_export_smx_size = 192;
3170		rdev->config.evergreen.max_hw_contexts = 8;
3171		rdev->config.evergreen.sq_num_cf_insts = 2;
3172
3173		rdev->config.evergreen.sc_prim_fifo_size = 0x100;
3174		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3175		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3176		gb_addr_config = CYPRESS_GB_ADDR_CONFIG_GOLDEN;
3177		break;
3178	case CHIP_JUNIPER:
3179		rdev->config.evergreen.num_ses = 1;
3180		rdev->config.evergreen.max_pipes = 4;
3181		rdev->config.evergreen.max_tile_pipes = 4;
3182		rdev->config.evergreen.max_simds = 10;
3183		rdev->config.evergreen.max_backends = 4 * rdev->config.evergreen.num_ses;
3184		rdev->config.evergreen.max_gprs = 256;
3185		rdev->config.evergreen.max_threads = 248;
3186		rdev->config.evergreen.max_gs_threads = 32;
3187		rdev->config.evergreen.max_stack_entries = 512;
3188		rdev->config.evergreen.sx_num_of_sets = 4;
3189		rdev->config.evergreen.sx_max_export_size = 256;
3190		rdev->config.evergreen.sx_max_export_pos_size = 64;
3191		rdev->config.evergreen.sx_max_export_smx_size = 192;
3192		rdev->config.evergreen.max_hw_contexts = 8;
3193		rdev->config.evergreen.sq_num_cf_insts = 2;
3194
3195		rdev->config.evergreen.sc_prim_fifo_size = 0x100;
3196		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3197		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3198		gb_addr_config = JUNIPER_GB_ADDR_CONFIG_GOLDEN;
3199		break;
3200	case CHIP_REDWOOD:
3201		rdev->config.evergreen.num_ses = 1;
3202		rdev->config.evergreen.max_pipes = 4;
3203		rdev->config.evergreen.max_tile_pipes = 4;
3204		rdev->config.evergreen.max_simds = 5;
3205		rdev->config.evergreen.max_backends = 2 * rdev->config.evergreen.num_ses;
3206		rdev->config.evergreen.max_gprs = 256;
3207		rdev->config.evergreen.max_threads = 248;
3208		rdev->config.evergreen.max_gs_threads = 32;
3209		rdev->config.evergreen.max_stack_entries = 256;
3210		rdev->config.evergreen.sx_num_of_sets = 4;
3211		rdev->config.evergreen.sx_max_export_size = 256;
3212		rdev->config.evergreen.sx_max_export_pos_size = 64;
3213		rdev->config.evergreen.sx_max_export_smx_size = 192;
3214		rdev->config.evergreen.max_hw_contexts = 8;
3215		rdev->config.evergreen.sq_num_cf_insts = 2;
3216
3217		rdev->config.evergreen.sc_prim_fifo_size = 0x100;
3218		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3219		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3220		gb_addr_config = REDWOOD_GB_ADDR_CONFIG_GOLDEN;
3221		break;
3222	case CHIP_CEDAR:
3223	default:
3224		rdev->config.evergreen.num_ses = 1;
3225		rdev->config.evergreen.max_pipes = 2;
3226		rdev->config.evergreen.max_tile_pipes = 2;
3227		rdev->config.evergreen.max_simds = 2;
3228		rdev->config.evergreen.max_backends = 1 * rdev->config.evergreen.num_ses;
3229		rdev->config.evergreen.max_gprs = 256;
3230		rdev->config.evergreen.max_threads = 192;
3231		rdev->config.evergreen.max_gs_threads = 16;
3232		rdev->config.evergreen.max_stack_entries = 256;
3233		rdev->config.evergreen.sx_num_of_sets = 4;
3234		rdev->config.evergreen.sx_max_export_size = 128;
3235		rdev->config.evergreen.sx_max_export_pos_size = 32;
3236		rdev->config.evergreen.sx_max_export_smx_size = 96;
3237		rdev->config.evergreen.max_hw_contexts = 4;
3238		rdev->config.evergreen.sq_num_cf_insts = 1;
3239
3240		rdev->config.evergreen.sc_prim_fifo_size = 0x40;
3241		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3242		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3243		gb_addr_config = CEDAR_GB_ADDR_CONFIG_GOLDEN;
3244		break;
3245	case CHIP_PALM:
3246		rdev->config.evergreen.num_ses = 1;
3247		rdev->config.evergreen.max_pipes = 2;
3248		rdev->config.evergreen.max_tile_pipes = 2;
3249		rdev->config.evergreen.max_simds = 2;
3250		rdev->config.evergreen.max_backends = 1 * rdev->config.evergreen.num_ses;
3251		rdev->config.evergreen.max_gprs = 256;
3252		rdev->config.evergreen.max_threads = 192;
3253		rdev->config.evergreen.max_gs_threads = 16;
3254		rdev->config.evergreen.max_stack_entries = 256;
3255		rdev->config.evergreen.sx_num_of_sets = 4;
3256		rdev->config.evergreen.sx_max_export_size = 128;
3257		rdev->config.evergreen.sx_max_export_pos_size = 32;
3258		rdev->config.evergreen.sx_max_export_smx_size = 96;
3259		rdev->config.evergreen.max_hw_contexts = 4;
3260		rdev->config.evergreen.sq_num_cf_insts = 1;
3261
3262		rdev->config.evergreen.sc_prim_fifo_size = 0x40;
3263		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3264		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3265		gb_addr_config = CEDAR_GB_ADDR_CONFIG_GOLDEN;
3266		break;
3267	case CHIP_SUMO:
3268		rdev->config.evergreen.num_ses = 1;
3269		rdev->config.evergreen.max_pipes = 4;
3270		rdev->config.evergreen.max_tile_pipes = 4;
3271		if (rdev->pdev->device == 0x9648)
3272			rdev->config.evergreen.max_simds = 3;
3273		else if ((rdev->pdev->device == 0x9647) ||
3274			 (rdev->pdev->device == 0x964a))
3275			rdev->config.evergreen.max_simds = 4;
3276		else
3277			rdev->config.evergreen.max_simds = 5;
3278		rdev->config.evergreen.max_backends = 2 * rdev->config.evergreen.num_ses;
3279		rdev->config.evergreen.max_gprs = 256;
3280		rdev->config.evergreen.max_threads = 248;
3281		rdev->config.evergreen.max_gs_threads = 32;
3282		rdev->config.evergreen.max_stack_entries = 256;
3283		rdev->config.evergreen.sx_num_of_sets = 4;
3284		rdev->config.evergreen.sx_max_export_size = 256;
3285		rdev->config.evergreen.sx_max_export_pos_size = 64;
3286		rdev->config.evergreen.sx_max_export_smx_size = 192;
3287		rdev->config.evergreen.max_hw_contexts = 8;
3288		rdev->config.evergreen.sq_num_cf_insts = 2;
3289
3290		rdev->config.evergreen.sc_prim_fifo_size = 0x40;
3291		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3292		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3293		gb_addr_config = SUMO_GB_ADDR_CONFIG_GOLDEN;
3294		break;
3295	case CHIP_SUMO2:
3296		rdev->config.evergreen.num_ses = 1;
3297		rdev->config.evergreen.max_pipes = 4;
3298		rdev->config.evergreen.max_tile_pipes = 4;
3299		rdev->config.evergreen.max_simds = 2;
3300		rdev->config.evergreen.max_backends = 1 * rdev->config.evergreen.num_ses;
3301		rdev->config.evergreen.max_gprs = 256;
3302		rdev->config.evergreen.max_threads = 248;
3303		rdev->config.evergreen.max_gs_threads = 32;
3304		rdev->config.evergreen.max_stack_entries = 512;
3305		rdev->config.evergreen.sx_num_of_sets = 4;
3306		rdev->config.evergreen.sx_max_export_size = 256;
3307		rdev->config.evergreen.sx_max_export_pos_size = 64;
3308		rdev->config.evergreen.sx_max_export_smx_size = 192;
3309		rdev->config.evergreen.max_hw_contexts = 4;
3310		rdev->config.evergreen.sq_num_cf_insts = 2;
3311
3312		rdev->config.evergreen.sc_prim_fifo_size = 0x40;
3313		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3314		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3315		gb_addr_config = SUMO2_GB_ADDR_CONFIG_GOLDEN;
3316		break;
3317	case CHIP_BARTS:
3318		rdev->config.evergreen.num_ses = 2;
3319		rdev->config.evergreen.max_pipes = 4;
3320		rdev->config.evergreen.max_tile_pipes = 8;
3321		rdev->config.evergreen.max_simds = 7;
3322		rdev->config.evergreen.max_backends = 4 * rdev->config.evergreen.num_ses;
3323		rdev->config.evergreen.max_gprs = 256;
3324		rdev->config.evergreen.max_threads = 248;
3325		rdev->config.evergreen.max_gs_threads = 32;
3326		rdev->config.evergreen.max_stack_entries = 512;
3327		rdev->config.evergreen.sx_num_of_sets = 4;
3328		rdev->config.evergreen.sx_max_export_size = 256;
3329		rdev->config.evergreen.sx_max_export_pos_size = 64;
3330		rdev->config.evergreen.sx_max_export_smx_size = 192;
3331		rdev->config.evergreen.max_hw_contexts = 8;
3332		rdev->config.evergreen.sq_num_cf_insts = 2;
3333
3334		rdev->config.evergreen.sc_prim_fifo_size = 0x100;
3335		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3336		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3337		gb_addr_config = BARTS_GB_ADDR_CONFIG_GOLDEN;
3338		break;
3339	case CHIP_TURKS:
3340		rdev->config.evergreen.num_ses = 1;
3341		rdev->config.evergreen.max_pipes = 4;
3342		rdev->config.evergreen.max_tile_pipes = 4;
3343		rdev->config.evergreen.max_simds = 6;
3344		rdev->config.evergreen.max_backends = 2 * rdev->config.evergreen.num_ses;
3345		rdev->config.evergreen.max_gprs = 256;
3346		rdev->config.evergreen.max_threads = 248;
3347		rdev->config.evergreen.max_gs_threads = 32;
3348		rdev->config.evergreen.max_stack_entries = 256;
3349		rdev->config.evergreen.sx_num_of_sets = 4;
3350		rdev->config.evergreen.sx_max_export_size = 256;
3351		rdev->config.evergreen.sx_max_export_pos_size = 64;
3352		rdev->config.evergreen.sx_max_export_smx_size = 192;
3353		rdev->config.evergreen.max_hw_contexts = 8;
3354		rdev->config.evergreen.sq_num_cf_insts = 2;
3355
3356		rdev->config.evergreen.sc_prim_fifo_size = 0x100;
3357		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3358		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3359		gb_addr_config = TURKS_GB_ADDR_CONFIG_GOLDEN;
3360		break;
3361	case CHIP_CAICOS:
3362		rdev->config.evergreen.num_ses = 1;
3363		rdev->config.evergreen.max_pipes = 2;
3364		rdev->config.evergreen.max_tile_pipes = 2;
3365		rdev->config.evergreen.max_simds = 2;
3366		rdev->config.evergreen.max_backends = 1 * rdev->config.evergreen.num_ses;
3367		rdev->config.evergreen.max_gprs = 256;
3368		rdev->config.evergreen.max_threads = 192;
3369		rdev->config.evergreen.max_gs_threads = 16;
3370		rdev->config.evergreen.max_stack_entries = 256;
3371		rdev->config.evergreen.sx_num_of_sets = 4;
3372		rdev->config.evergreen.sx_max_export_size = 128;
3373		rdev->config.evergreen.sx_max_export_pos_size = 32;
3374		rdev->config.evergreen.sx_max_export_smx_size = 96;
3375		rdev->config.evergreen.max_hw_contexts = 4;
3376		rdev->config.evergreen.sq_num_cf_insts = 1;
3377
3378		rdev->config.evergreen.sc_prim_fifo_size = 0x40;
3379		rdev->config.evergreen.sc_hiz_tile_fifo_size = 0x30;
3380		rdev->config.evergreen.sc_earlyz_tile_fifo_size = 0x130;
3381		gb_addr_config = CAICOS_GB_ADDR_CONFIG_GOLDEN;
3382		break;
3383	}
3384
3385	/* Initialize HDP */
3386	for (i = 0, j = 0; i < 32; i++, j += 0x18) {
3387		WREG32((0x2c14 + j), 0x00000000);
3388		WREG32((0x2c18 + j), 0x00000000);
3389		WREG32((0x2c1c + j), 0x00000000);
3390		WREG32((0x2c20 + j), 0x00000000);
3391		WREG32((0x2c24 + j), 0x00000000);
3392	}
3393
3394	WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
3395	WREG32(SRBM_INT_CNTL, 0x1);
3396	WREG32(SRBM_INT_ACK, 0x1);
3397
3398	evergreen_fix_pci_max_read_req_size(rdev);
3399
3400	mc_shared_chmap = RREG32(MC_SHARED_CHMAP);
3401	if ((rdev->family == CHIP_PALM) ||
3402	    (rdev->family == CHIP_SUMO) ||
3403	    (rdev->family == CHIP_SUMO2))
3404		mc_arb_ramcfg = RREG32(FUS_MC_ARB_RAMCFG);
3405	else
3406		mc_arb_ramcfg = RREG32(MC_ARB_RAMCFG);
3407
3408	/* setup tiling info dword.  gb_addr_config is not adequate since it does
3409	 * not have bank info, so create a custom tiling dword.
3410	 * bits 3:0   num_pipes
3411	 * bits 7:4   num_banks
3412	 * bits 11:8  group_size
3413	 * bits 15:12 row_size
3414	 */
3415	rdev->config.evergreen.tile_config = 0;
3416	switch (rdev->config.evergreen.max_tile_pipes) {
3417	case 1:
3418	default:
3419		rdev->config.evergreen.tile_config |= (0 << 0);
3420		break;
3421	case 2:
3422		rdev->config.evergreen.tile_config |= (1 << 0);
3423		break;
3424	case 4:
3425		rdev->config.evergreen.tile_config |= (2 << 0);
3426		break;
3427	case 8:
3428		rdev->config.evergreen.tile_config |= (3 << 0);
3429		break;
3430	}
3431	/* num banks is 8 on all fusion asics. 0 = 4, 1 = 8, 2 = 16 */
3432	if (rdev->flags & RADEON_IS_IGP)
3433		rdev->config.evergreen.tile_config |= 1 << 4;
3434	else {
3435		switch ((mc_arb_ramcfg & NOOFBANK_MASK) >> NOOFBANK_SHIFT) {
3436		case 0: /* four banks */
3437			rdev->config.evergreen.tile_config |= 0 << 4;
3438			break;
3439		case 1: /* eight banks */
3440			rdev->config.evergreen.tile_config |= 1 << 4;
3441			break;
3442		case 2: /* sixteen banks */
3443		default:
3444			rdev->config.evergreen.tile_config |= 2 << 4;
3445			break;
3446		}
3447	}
3448	rdev->config.evergreen.tile_config |= 0 << 8;
3449	rdev->config.evergreen.tile_config |=
3450		((gb_addr_config & 0x30000000) >> 28) << 12;
3451
3452	if ((rdev->family >= CHIP_CEDAR) && (rdev->family <= CHIP_HEMLOCK)) {
3453		u32 efuse_straps_4;
3454		u32 efuse_straps_3;
3455
3456		efuse_straps_4 = RREG32_RCU(0x204);
3457		efuse_straps_3 = RREG32_RCU(0x203);
3458		tmp = (((efuse_straps_4 & 0xf) << 4) |
3459		      ((efuse_straps_3 & 0xf0000000) >> 28));
3460	} else {
3461		tmp = 0;
3462		for (i = (rdev->config.evergreen.num_ses - 1); i >= 0; i--) {
3463			u32 rb_disable_bitmap;
3464
3465			WREG32(GRBM_GFX_INDEX, INSTANCE_BROADCAST_WRITES | SE_INDEX(i));
3466			WREG32(RLC_GFX_INDEX, INSTANCE_BROADCAST_WRITES | SE_INDEX(i));
3467			rb_disable_bitmap = (RREG32(CC_RB_BACKEND_DISABLE) & 0x00ff0000) >> 16;
3468			tmp <<= 4;
3469			tmp |= rb_disable_bitmap;
3470		}
3471	}
3472	/* enabled rb are just the one not disabled :) */
3473	disabled_rb_mask = tmp;
3474	tmp = 0;
3475	for (i = 0; i < rdev->config.evergreen.max_backends; i++)
3476		tmp |= (1 << i);
3477	/* if all the backends are disabled, fix it up here */
3478	if ((disabled_rb_mask & tmp) == tmp) {
3479		for (i = 0; i < rdev->config.evergreen.max_backends; i++)
3480			disabled_rb_mask &= ~(1 << i);
3481	}
3482
3483	for (i = 0; i < rdev->config.evergreen.num_ses; i++) {
3484		u32 simd_disable_bitmap;
3485
3486		WREG32(GRBM_GFX_INDEX, INSTANCE_BROADCAST_WRITES | SE_INDEX(i));
3487		WREG32(RLC_GFX_INDEX, INSTANCE_BROADCAST_WRITES | SE_INDEX(i));
3488		simd_disable_bitmap = (RREG32(CC_GC_SHADER_PIPE_CONFIG) & 0xffff0000) >> 16;
3489		simd_disable_bitmap |= 0xffffffff << rdev->config.evergreen.max_simds;
3490		tmp <<= 16;
3491		tmp |= simd_disable_bitmap;
3492	}
3493	rdev->config.evergreen.active_simds = hweight32(~tmp);
3494
3495	WREG32(GRBM_GFX_INDEX, INSTANCE_BROADCAST_WRITES | SE_BROADCAST_WRITES);
3496	WREG32(RLC_GFX_INDEX, INSTANCE_BROADCAST_WRITES | SE_BROADCAST_WRITES);
3497
3498	WREG32(GB_ADDR_CONFIG, gb_addr_config);
3499	WREG32(DMIF_ADDR_CONFIG, gb_addr_config);
3500	WREG32(HDP_ADDR_CONFIG, gb_addr_config);
3501	WREG32(DMA_TILING_CONFIG, gb_addr_config);
3502	WREG32(UVD_UDEC_ADDR_CONFIG, gb_addr_config);
3503	WREG32(UVD_UDEC_DB_ADDR_CONFIG, gb_addr_config);
3504	WREG32(UVD_UDEC_DBW_ADDR_CONFIG, gb_addr_config);
3505
3506	if ((rdev->config.evergreen.max_backends == 1) &&
3507	    (rdev->flags & RADEON_IS_IGP)) {
3508		if ((disabled_rb_mask & 3) == 1) {
3509			/* RB0 disabled, RB1 enabled */
3510			tmp = 0x11111111;
3511		} else {
3512			/* RB1 disabled, RB0 enabled */
3513			tmp = 0x00000000;
3514		}
3515	} else {
3516		tmp = gb_addr_config & NUM_PIPES_MASK;
3517		tmp = r6xx_remap_render_backend(rdev, tmp, rdev->config.evergreen.max_backends,
3518						EVERGREEN_MAX_BACKENDS, disabled_rb_mask);
3519	}
3520	rdev->config.evergreen.backend_map = tmp;
3521	WREG32(GB_BACKEND_MAP, tmp);
3522
3523	WREG32(CGTS_SYS_TCC_DISABLE, 0);
3524	WREG32(CGTS_TCC_DISABLE, 0);
3525	WREG32(CGTS_USER_SYS_TCC_DISABLE, 0);
3526	WREG32(CGTS_USER_TCC_DISABLE, 0);
3527
3528	/* set HW defaults for 3D engine */
3529	WREG32(CP_QUEUE_THRESHOLDS, (ROQ_IB1_START(0x16) |
3530				     ROQ_IB2_START(0x2b)));
3531
3532	WREG32(CP_MEQ_THRESHOLDS, STQ_SPLIT(0x30));
3533
3534	WREG32(TA_CNTL_AUX, (DISABLE_CUBE_ANISO |
3535			     SYNC_GRADIENT |
3536			     SYNC_WALKER |
3537			     SYNC_ALIGNER));
3538
3539	sx_debug_1 = RREG32(SX_DEBUG_1);
3540	sx_debug_1 |= ENABLE_NEW_SMX_ADDRESS;
3541	WREG32(SX_DEBUG_1, sx_debug_1);
3542
3543
3544	smx_dc_ctl0 = RREG32(SMX_DC_CTL0);
3545	smx_dc_ctl0 &= ~NUMBER_OF_SETS(0x1ff);
3546	smx_dc_ctl0 |= NUMBER_OF_SETS(rdev->config.evergreen.sx_num_of_sets);
3547	WREG32(SMX_DC_CTL0, smx_dc_ctl0);
3548
3549	if (rdev->family <= CHIP_SUMO2)
3550		WREG32(SMX_SAR_CTL0, 0x00010000);
3551
3552	WREG32(SX_EXPORT_BUFFER_SIZES, (COLOR_BUFFER_SIZE((rdev->config.evergreen.sx_max_export_size / 4) - 1) |
3553					POSITION_BUFFER_SIZE((rdev->config.evergreen.sx_max_export_pos_size / 4) - 1) |
3554					SMX_BUFFER_SIZE((rdev->config.evergreen.sx_max_export_smx_size / 4) - 1)));
3555
3556	WREG32(PA_SC_FIFO_SIZE, (SC_PRIM_FIFO_SIZE(rdev->config.evergreen.sc_prim_fifo_size) |
3557				 SC_HIZ_TILE_FIFO_SIZE(rdev->config.evergreen.sc_hiz_tile_fifo_size) |
3558				 SC_EARLYZ_TILE_FIFO_SIZE(rdev->config.evergreen.sc_earlyz_tile_fifo_size)));
3559
3560	WREG32(VGT_NUM_INSTANCES, 1);
3561	WREG32(SPI_CONFIG_CNTL, 0);
3562	WREG32(SPI_CONFIG_CNTL_1, VTX_DONE_DELAY(4));
3563	WREG32(CP_PERFMON_CNTL, 0);
3564
3565	WREG32(SQ_MS_FIFO_SIZES, (CACHE_FIFO_SIZE(16 * rdev->config.evergreen.sq_num_cf_insts) |
3566				  FETCH_FIFO_HIWATER(0x4) |
3567				  DONE_FIFO_HIWATER(0xe0) |
3568				  ALU_UPDATE_FIFO_HIWATER(0x8)));
3569
3570	sq_config = RREG32(SQ_CONFIG);
3571	sq_config &= ~(PS_PRIO(3) |
3572		       VS_PRIO(3) |
3573		       GS_PRIO(3) |
3574		       ES_PRIO(3));
3575	sq_config |= (VC_ENABLE |
3576		      EXPORT_SRC_C |
3577		      PS_PRIO(0) |
3578		      VS_PRIO(1) |
3579		      GS_PRIO(2) |
3580		      ES_PRIO(3));
3581
3582	switch (rdev->family) {
3583	case CHIP_CEDAR:
3584	case CHIP_PALM:
3585	case CHIP_SUMO:
3586	case CHIP_SUMO2:
3587	case CHIP_CAICOS:
3588		/* no vertex cache */
3589		sq_config &= ~VC_ENABLE;
3590		break;
3591	default:
3592		break;
3593	}
3594
3595	sq_lds_resource_mgmt = RREG32(SQ_LDS_RESOURCE_MGMT);
3596
3597	sq_gpr_resource_mgmt_1 = NUM_PS_GPRS((rdev->config.evergreen.max_gprs - (4 * 2))* 12 / 32);
3598	sq_gpr_resource_mgmt_1 |= NUM_VS_GPRS((rdev->config.evergreen.max_gprs - (4 * 2)) * 6 / 32);
3599	sq_gpr_resource_mgmt_1 |= NUM_CLAUSE_TEMP_GPRS(4);
3600	sq_gpr_resource_mgmt_2 = NUM_GS_GPRS((rdev->config.evergreen.max_gprs - (4 * 2)) * 4 / 32);
3601	sq_gpr_resource_mgmt_2 |= NUM_ES_GPRS((rdev->config.evergreen.max_gprs - (4 * 2)) * 4 / 32);
3602	sq_gpr_resource_mgmt_3 = NUM_HS_GPRS((rdev->config.evergreen.max_gprs - (4 * 2)) * 3 / 32);
3603	sq_gpr_resource_mgmt_3 |= NUM_LS_GPRS((rdev->config.evergreen.max_gprs - (4 * 2)) * 3 / 32);
3604
3605	switch (rdev->family) {
3606	case CHIP_CEDAR:
3607	case CHIP_PALM:
3608	case CHIP_SUMO:
3609	case CHIP_SUMO2:
3610		ps_thread_count = 96;
3611		break;
3612	default:
3613		ps_thread_count = 128;
3614		break;
3615	}
3616
3617	sq_thread_resource_mgmt = NUM_PS_THREADS(ps_thread_count);
3618	sq_thread_resource_mgmt |= NUM_VS_THREADS((((rdev->config.evergreen.max_threads - ps_thread_count) / 6) / 8) * 8);
3619	sq_thread_resource_mgmt |= NUM_GS_THREADS((((rdev->config.evergreen.max_threads - ps_thread_count) / 6) / 8) * 8);
3620	sq_thread_resource_mgmt |= NUM_ES_THREADS((((rdev->config.evergreen.max_threads - ps_thread_count) / 6) / 8) * 8);
3621	sq_thread_resource_mgmt_2 = NUM_HS_THREADS((((rdev->config.evergreen.max_threads - ps_thread_count) / 6) / 8) * 8);
3622	sq_thread_resource_mgmt_2 |= NUM_LS_THREADS((((rdev->config.evergreen.max_threads - ps_thread_count) / 6) / 8) * 8);
3623
3624	sq_stack_resource_mgmt_1 = NUM_PS_STACK_ENTRIES((rdev->config.evergreen.max_stack_entries * 1) / 6);
3625	sq_stack_resource_mgmt_1 |= NUM_VS_STACK_ENTRIES((rdev->config.evergreen.max_stack_entries * 1) / 6);
3626	sq_stack_resource_mgmt_2 = NUM_GS_STACK_ENTRIES((rdev->config.evergreen.max_stack_entries * 1) / 6);
3627	sq_stack_resource_mgmt_2 |= NUM_ES_STACK_ENTRIES((rdev->config.evergreen.max_stack_entries * 1) / 6);
3628	sq_stack_resource_mgmt_3 = NUM_HS_STACK_ENTRIES((rdev->config.evergreen.max_stack_entries * 1) / 6);
3629	sq_stack_resource_mgmt_3 |= NUM_LS_STACK_ENTRIES((rdev->config.evergreen.max_stack_entries * 1) / 6);
3630
3631	WREG32(SQ_CONFIG, sq_config);
3632	WREG32(SQ_GPR_RESOURCE_MGMT_1, sq_gpr_resource_mgmt_1);
3633	WREG32(SQ_GPR_RESOURCE_MGMT_2, sq_gpr_resource_mgmt_2);
3634	WREG32(SQ_GPR_RESOURCE_MGMT_3, sq_gpr_resource_mgmt_3);
3635	WREG32(SQ_THREAD_RESOURCE_MGMT, sq_thread_resource_mgmt);
3636	WREG32(SQ_THREAD_RESOURCE_MGMT_2, sq_thread_resource_mgmt_2);
3637	WREG32(SQ_STACK_RESOURCE_MGMT_1, sq_stack_resource_mgmt_1);
3638	WREG32(SQ_STACK_RESOURCE_MGMT_2, sq_stack_resource_mgmt_2);
3639	WREG32(SQ_STACK_RESOURCE_MGMT_3, sq_stack_resource_mgmt_3);
3640	WREG32(SQ_DYN_GPR_CNTL_PS_FLUSH_REQ, 0);
3641	WREG32(SQ_LDS_RESOURCE_MGMT, sq_lds_resource_mgmt);
3642
3643	WREG32(PA_SC_FORCE_EOV_MAX_CNTS, (FORCE_EOV_MAX_CLK_CNT(4095) |
3644					  FORCE_EOV_MAX_REZ_CNT(255)));
3645
3646	switch (rdev->family) {
3647	case CHIP_CEDAR:
3648	case CHIP_PALM:
3649	case CHIP_SUMO:
3650	case CHIP_SUMO2:
3651	case CHIP_CAICOS:
3652		vgt_cache_invalidation = CACHE_INVALIDATION(TC_ONLY);
3653		break;
3654	default:
3655		vgt_cache_invalidation = CACHE_INVALIDATION(VC_AND_TC);
3656		break;
3657	}
3658	vgt_cache_invalidation |= AUTO_INVLD_EN(ES_AND_GS_AUTO);
3659	WREG32(VGT_CACHE_INVALIDATION, vgt_cache_invalidation);
3660
3661	WREG32(VGT_GS_VERTEX_REUSE, 16);
3662	WREG32(PA_SU_LINE_STIPPLE_VALUE, 0);
3663	WREG32(PA_SC_LINE_STIPPLE_STATE, 0);
3664
3665	WREG32(VGT_VERTEX_REUSE_BLOCK_CNTL, 14);
3666	WREG32(VGT_OUT_DEALLOC_CNTL, 16);
3667
3668	WREG32(CB_PERF_CTR0_SEL_0, 0);
3669	WREG32(CB_PERF_CTR0_SEL_1, 0);
3670	WREG32(CB_PERF_CTR1_SEL_0, 0);
3671	WREG32(CB_PERF_CTR1_SEL_1, 0);
3672	WREG32(CB_PERF_CTR2_SEL_0, 0);
3673	WREG32(CB_PERF_CTR2_SEL_1, 0);
3674	WREG32(CB_PERF_CTR3_SEL_0, 0);
3675	WREG32(CB_PERF_CTR3_SEL_1, 0);
3676
3677	/* clear render buffer base addresses */
3678	WREG32(CB_COLOR0_BASE, 0);
3679	WREG32(CB_COLOR1_BASE, 0);
3680	WREG32(CB_COLOR2_BASE, 0);
3681	WREG32(CB_COLOR3_BASE, 0);
3682	WREG32(CB_COLOR4_BASE, 0);
3683	WREG32(CB_COLOR5_BASE, 0);
3684	WREG32(CB_COLOR6_BASE, 0);
3685	WREG32(CB_COLOR7_BASE, 0);
3686	WREG32(CB_COLOR8_BASE, 0);
3687	WREG32(CB_COLOR9_BASE, 0);
3688	WREG32(CB_COLOR10_BASE, 0);
3689	WREG32(CB_COLOR11_BASE, 0);
3690
3691	/* set the shader const cache sizes to 0 */
3692	for (i = SQ_ALU_CONST_BUFFER_SIZE_PS_0; i < 0x28200; i += 4)
3693		WREG32(i, 0);
3694	for (i = SQ_ALU_CONST_BUFFER_SIZE_HS_0; i < 0x29000; i += 4)
3695		WREG32(i, 0);
3696
3697	tmp = RREG32(HDP_MISC_CNTL);
3698	tmp |= HDP_FLUSH_INVALIDATE_CACHE;
3699	WREG32(HDP_MISC_CNTL, tmp);
3700
3701	hdp_host_path_cntl = RREG32(HDP_HOST_PATH_CNTL);
3702	WREG32(HDP_HOST_PATH_CNTL, hdp_host_path_cntl);
3703
3704	WREG32(PA_CL_ENHANCE, CLIP_VTX_REORDER_ENA | NUM_CLIP_SEQ(3));
3705
3706	udelay(50);
3707
3708}
3709
3710int evergreen_mc_init(struct radeon_device *rdev)
3711{
3712	u32 tmp;
3713	int chansize, numchan;
3714
3715	/* Get VRAM informations */
3716	rdev->mc.vram_is_ddr = true;
3717	if ((rdev->family == CHIP_PALM) ||
3718	    (rdev->family == CHIP_SUMO) ||
3719	    (rdev->family == CHIP_SUMO2))
3720		tmp = RREG32(FUS_MC_ARB_RAMCFG);
3721	else
3722		tmp = RREG32(MC_ARB_RAMCFG);
3723	if (tmp & CHANSIZE_OVERRIDE) {
3724		chansize = 16;
3725	} else if (tmp & CHANSIZE_MASK) {
3726		chansize = 64;
3727	} else {
3728		chansize = 32;
3729	}
3730	tmp = RREG32(MC_SHARED_CHMAP);
3731	switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) {
3732	case 0:
3733	default:
3734		numchan = 1;
3735		break;
3736	case 1:
3737		numchan = 2;
3738		break;
3739	case 2:
3740		numchan = 4;
3741		break;
3742	case 3:
3743		numchan = 8;
3744		break;
3745	}
3746	rdev->mc.vram_width = numchan * chansize;
3747	/* Could aper size report 0 ? */
3748	rdev->mc.aper_base = pci_resource_start(rdev->pdev, 0);
3749	rdev->mc.aper_size = pci_resource_len(rdev->pdev, 0);
3750	/* Setup GPU memory space */
3751	if ((rdev->family == CHIP_PALM) ||
3752	    (rdev->family == CHIP_SUMO) ||
3753	    (rdev->family == CHIP_SUMO2)) {
3754		/* size in bytes on fusion */
3755		rdev->mc.mc_vram_size = RREG32(CONFIG_MEMSIZE);
3756		rdev->mc.real_vram_size = RREG32(CONFIG_MEMSIZE);
3757	} else {
3758		/* size in MB on evergreen/cayman/tn */
3759		rdev->mc.mc_vram_size = RREG32(CONFIG_MEMSIZE) * 1024ULL * 1024ULL;
3760		rdev->mc.real_vram_size = RREG32(CONFIG_MEMSIZE) * 1024ULL * 1024ULL;
3761	}
3762	rdev->mc.visible_vram_size = rdev->mc.aper_size;
3763	r700_vram_gtt_location(rdev, &rdev->mc);
3764	radeon_update_bandwidth_info(rdev);
3765
3766	return 0;
3767}
3768
3769void evergreen_print_gpu_status_regs(struct radeon_device *rdev)
3770{
3771	dev_info(rdev->dev, "  GRBM_STATUS               = 0x%08X\n",
3772		RREG32(GRBM_STATUS));
3773	dev_info(rdev->dev, "  GRBM_STATUS_SE0           = 0x%08X\n",
3774		RREG32(GRBM_STATUS_SE0));
3775	dev_info(rdev->dev, "  GRBM_STATUS_SE1           = 0x%08X\n",
3776		RREG32(GRBM_STATUS_SE1));
3777	dev_info(rdev->dev, "  SRBM_STATUS               = 0x%08X\n",
3778		RREG32(SRBM_STATUS));
3779	dev_info(rdev->dev, "  SRBM_STATUS2              = 0x%08X\n",
3780		RREG32(SRBM_STATUS2));
3781	dev_info(rdev->dev, "  R_008674_CP_STALLED_STAT1 = 0x%08X\n",
3782		RREG32(CP_STALLED_STAT1));
3783	dev_info(rdev->dev, "  R_008678_CP_STALLED_STAT2 = 0x%08X\n",
3784		RREG32(CP_STALLED_STAT2));
3785	dev_info(rdev->dev, "  R_00867C_CP_BUSY_STAT     = 0x%08X\n",
3786		RREG32(CP_BUSY_STAT));
3787	dev_info(rdev->dev, "  R_008680_CP_STAT          = 0x%08X\n",
3788		RREG32(CP_STAT));
3789	dev_info(rdev->dev, "  R_00D034_DMA_STATUS_REG   = 0x%08X\n",
3790		RREG32(DMA_STATUS_REG));
3791	if (rdev->family >= CHIP_CAYMAN) {
3792		dev_info(rdev->dev, "  R_00D834_DMA_STATUS_REG   = 0x%08X\n",
3793			 RREG32(DMA_STATUS_REG + 0x800));
3794	}
3795}
3796
3797bool evergreen_is_display_hung(struct radeon_device *rdev)
3798{
3799	u32 crtc_hung = 0;
3800	u32 crtc_status[6];
3801	u32 i, j, tmp;
3802
3803	for (i = 0; i < rdev->num_crtc; i++) {
3804		if (RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i]) & EVERGREEN_CRTC_MASTER_EN) {
3805			crtc_status[i] = RREG32(EVERGREEN_CRTC_STATUS_HV_COUNT + crtc_offsets[i]);
3806			crtc_hung |= (1 << i);
3807		}
3808	}
3809
3810	for (j = 0; j < 10; j++) {
3811		for (i = 0; i < rdev->num_crtc; i++) {
3812			if (crtc_hung & (1 << i)) {
3813				tmp = RREG32(EVERGREEN_CRTC_STATUS_HV_COUNT + crtc_offsets[i]);
3814				if (tmp != crtc_status[i])
3815					crtc_hung &= ~(1 << i);
3816			}
3817		}
3818		if (crtc_hung == 0)
3819			return false;
3820		udelay(100);
3821	}
3822
3823	return true;
3824}
3825
3826u32 evergreen_gpu_check_soft_reset(struct radeon_device *rdev)
3827{
3828	u32 reset_mask = 0;
3829	u32 tmp;
3830
3831	/* GRBM_STATUS */
3832	tmp = RREG32(GRBM_STATUS);
3833	if (tmp & (PA_BUSY | SC_BUSY |
3834		   SH_BUSY | SX_BUSY |
3835		   TA_BUSY | VGT_BUSY |
3836		   DB_BUSY | CB_BUSY |
3837		   SPI_BUSY | VGT_BUSY_NO_DMA))
3838		reset_mask |= RADEON_RESET_GFX;
3839
3840	if (tmp & (CF_RQ_PENDING | PF_RQ_PENDING |
3841		   CP_BUSY | CP_COHERENCY_BUSY))
3842		reset_mask |= RADEON_RESET_CP;
3843
3844	if (tmp & GRBM_EE_BUSY)
3845		reset_mask |= RADEON_RESET_GRBM | RADEON_RESET_GFX | RADEON_RESET_CP;
3846
3847	/* DMA_STATUS_REG */
3848	tmp = RREG32(DMA_STATUS_REG);
3849	if (!(tmp & DMA_IDLE))
3850		reset_mask |= RADEON_RESET_DMA;
3851
3852	/* SRBM_STATUS2 */
3853	tmp = RREG32(SRBM_STATUS2);
3854	if (tmp & DMA_BUSY)
3855		reset_mask |= RADEON_RESET_DMA;
3856
3857	/* SRBM_STATUS */
3858	tmp = RREG32(SRBM_STATUS);
3859	if (tmp & (RLC_RQ_PENDING | RLC_BUSY))
3860		reset_mask |= RADEON_RESET_RLC;
3861
3862	if (tmp & IH_BUSY)
3863		reset_mask |= RADEON_RESET_IH;
3864
3865	if (tmp & SEM_BUSY)
3866		reset_mask |= RADEON_RESET_SEM;
3867
3868	if (tmp & GRBM_RQ_PENDING)
3869		reset_mask |= RADEON_RESET_GRBM;
3870
3871	if (tmp & VMC_BUSY)
3872		reset_mask |= RADEON_RESET_VMC;
3873
3874	if (tmp & (MCB_BUSY | MCB_NON_DISPLAY_BUSY |
3875		   MCC_BUSY | MCD_BUSY))
3876		reset_mask |= RADEON_RESET_MC;
3877
3878	if (evergreen_is_display_hung(rdev))
3879		reset_mask |= RADEON_RESET_DISPLAY;
3880
3881	/* VM_L2_STATUS */
3882	tmp = RREG32(VM_L2_STATUS);
3883	if (tmp & L2_BUSY)
3884		reset_mask |= RADEON_RESET_VMC;
3885
3886	/* Skip MC reset as it's mostly likely not hung, just busy */
3887	if (reset_mask & RADEON_RESET_MC) {
3888		DRM_DEBUG("MC busy: 0x%08X, clearing.\n", reset_mask);
3889		reset_mask &= ~RADEON_RESET_MC;
3890	}
3891
3892	return reset_mask;
3893}
3894
3895static void evergreen_gpu_soft_reset(struct radeon_device *rdev, u32 reset_mask)
3896{
3897	struct evergreen_mc_save save;
3898	u32 grbm_soft_reset = 0, srbm_soft_reset = 0;
3899	u32 tmp;
3900
3901	if (reset_mask == 0)
3902		return;
3903
3904	dev_info(rdev->dev, "GPU softreset: 0x%08X\n", reset_mask);
3905
3906	evergreen_print_gpu_status_regs(rdev);
3907
3908	/* Disable CP parsing/prefetching */
3909	WREG32(CP_ME_CNTL, CP_ME_HALT | CP_PFP_HALT);
3910
3911	if (reset_mask & RADEON_RESET_DMA) {
3912		/* Disable DMA */
3913		tmp = RREG32(DMA_RB_CNTL);
3914		tmp &= ~DMA_RB_ENABLE;
3915		WREG32(DMA_RB_CNTL, tmp);
3916	}
3917
3918	udelay(50);
3919
3920	evergreen_mc_stop(rdev, &save);
3921	if (evergreen_mc_wait_for_idle(rdev)) {
3922		dev_warn(rdev->dev, "Wait for MC idle timedout !\n");
3923	}
3924
3925	if (reset_mask & (RADEON_RESET_GFX | RADEON_RESET_COMPUTE)) {
3926		grbm_soft_reset |= SOFT_RESET_DB |
3927			SOFT_RESET_CB |
3928			SOFT_RESET_PA |
3929			SOFT_RESET_SC |
3930			SOFT_RESET_SPI |
3931			SOFT_RESET_SX |
3932			SOFT_RESET_SH |
3933			SOFT_RESET_TC |
3934			SOFT_RESET_TA |
3935			SOFT_RESET_VC |
3936			SOFT_RESET_VGT;
3937	}
3938
3939	if (reset_mask & RADEON_RESET_CP) {
3940		grbm_soft_reset |= SOFT_RESET_CP |
3941			SOFT_RESET_VGT;
3942
3943		srbm_soft_reset |= SOFT_RESET_GRBM;
3944	}
3945
3946	if (reset_mask & RADEON_RESET_DMA)
3947		srbm_soft_reset |= SOFT_RESET_DMA;
3948
3949	if (reset_mask & RADEON_RESET_DISPLAY)
3950		srbm_soft_reset |= SOFT_RESET_DC;
3951
3952	if (reset_mask & RADEON_RESET_RLC)
3953		srbm_soft_reset |= SOFT_RESET_RLC;
3954
3955	if (reset_mask & RADEON_RESET_SEM)
3956		srbm_soft_reset |= SOFT_RESET_SEM;
3957
3958	if (reset_mask & RADEON_RESET_IH)
3959		srbm_soft_reset |= SOFT_RESET_IH;
3960
3961	if (reset_mask & RADEON_RESET_GRBM)
3962		srbm_soft_reset |= SOFT_RESET_GRBM;
3963
3964	if (reset_mask & RADEON_RESET_VMC)
3965		srbm_soft_reset |= SOFT_RESET_VMC;
3966
3967	if (!(rdev->flags & RADEON_IS_IGP)) {
3968		if (reset_mask & RADEON_RESET_MC)
3969			srbm_soft_reset |= SOFT_RESET_MC;
3970	}
3971
3972	if (grbm_soft_reset) {
3973		tmp = RREG32(GRBM_SOFT_RESET);
3974		tmp |= grbm_soft_reset;
3975		dev_info(rdev->dev, "GRBM_SOFT_RESET=0x%08X\n", tmp);
3976		WREG32(GRBM_SOFT_RESET, tmp);
3977		tmp = RREG32(GRBM_SOFT_RESET);
3978
3979		udelay(50);
3980
3981		tmp &= ~grbm_soft_reset;
3982		WREG32(GRBM_SOFT_RESET, tmp);
3983		tmp = RREG32(GRBM_SOFT_RESET);
3984	}
3985
3986	if (srbm_soft_reset) {
3987		tmp = RREG32(SRBM_SOFT_RESET);
3988		tmp |= srbm_soft_reset;
3989		dev_info(rdev->dev, "SRBM_SOFT_RESET=0x%08X\n", tmp);
3990		WREG32(SRBM_SOFT_RESET, tmp);
3991		tmp = RREG32(SRBM_SOFT_RESET);
3992
3993		udelay(50);
3994
3995		tmp &= ~srbm_soft_reset;
3996		WREG32(SRBM_SOFT_RESET, tmp);
3997		tmp = RREG32(SRBM_SOFT_RESET);
3998	}
3999
4000	/* Wait a little for things to settle down */
4001	udelay(50);
4002
4003	evergreen_mc_resume(rdev, &save);
4004	udelay(50);
4005
4006	evergreen_print_gpu_status_regs(rdev);
4007}
4008
4009void evergreen_gpu_pci_config_reset(struct radeon_device *rdev)
4010{
4011	struct evergreen_mc_save save;
4012	u32 tmp, i;
4013
4014	dev_info(rdev->dev, "GPU pci config reset\n");
4015
4016	/* disable dpm? */
4017
4018	/* Disable CP parsing/prefetching */
4019	WREG32(CP_ME_CNTL, CP_ME_HALT | CP_PFP_HALT);
4020	udelay(50);
4021	/* Disable DMA */
4022	tmp = RREG32(DMA_RB_CNTL);
4023	tmp &= ~DMA_RB_ENABLE;
4024	WREG32(DMA_RB_CNTL, tmp);
4025	/* XXX other engines? */
4026
4027	/* halt the rlc */
4028	r600_rlc_stop(rdev);
4029
4030	udelay(50);
4031
4032	/* set mclk/sclk to bypass */
4033	rv770_set_clk_bypass_mode(rdev);
4034	/* disable BM */
4035	pci_clear_master(rdev->pdev);
4036	/* disable mem access */
4037	evergreen_mc_stop(rdev, &save);
4038	if (evergreen_mc_wait_for_idle(rdev)) {
4039		dev_warn(rdev->dev, "Wait for MC idle timed out !\n");
4040	}
4041	/* reset */
4042	radeon_pci_config_reset(rdev);
4043	/* wait for asic to come out of reset */
4044	for (i = 0; i < rdev->usec_timeout; i++) {
4045		if (RREG32(CONFIG_MEMSIZE) != 0xffffffff)
4046			break;
4047		udelay(1);
4048	}
4049}
4050
4051int evergreen_asic_reset(struct radeon_device *rdev, bool hard)
4052{
4053	u32 reset_mask;
4054
4055	if (hard) {
4056		evergreen_gpu_pci_config_reset(rdev);
4057		return 0;
4058	}
4059
4060	reset_mask = evergreen_gpu_check_soft_reset(rdev);
4061
4062	if (reset_mask)
4063		r600_set_bios_scratch_engine_hung(rdev, true);
4064
4065	/* try soft reset */
4066	evergreen_gpu_soft_reset(rdev, reset_mask);
4067
4068	reset_mask = evergreen_gpu_check_soft_reset(rdev);
4069
4070	/* try pci config reset */
4071	if (reset_mask && radeon_hard_reset)
4072		evergreen_gpu_pci_config_reset(rdev);
4073
4074	reset_mask = evergreen_gpu_check_soft_reset(rdev);
4075
4076	if (!reset_mask)
4077		r600_set_bios_scratch_engine_hung(rdev, false);
4078
4079	return 0;
4080}
4081
4082/**
4083 * evergreen_gfx_is_lockup - Check if the GFX engine is locked up
4084 *
4085 * @rdev: radeon_device pointer
4086 * @ring: radeon_ring structure holding ring information
4087 *
4088 * Check if the GFX engine is locked up.
4089 * Returns true if the engine appears to be locked up, false if not.
4090 */
4091bool evergreen_gfx_is_lockup(struct radeon_device *rdev, struct radeon_ring *ring)
4092{
4093	u32 reset_mask = evergreen_gpu_check_soft_reset(rdev);
4094
4095	if (!(reset_mask & (RADEON_RESET_GFX |
4096			    RADEON_RESET_COMPUTE |
4097			    RADEON_RESET_CP))) {
4098		radeon_ring_lockup_update(rdev, ring);
4099		return false;
4100	}
4101	return radeon_ring_test_lockup(rdev, ring);
4102}
4103
4104/*
4105 * RLC
4106 */
4107#define RLC_SAVE_RESTORE_LIST_END_MARKER    0x00000000
4108#define RLC_CLEAR_STATE_END_MARKER          0x00000001
4109
4110void sumo_rlc_fini(struct radeon_device *rdev)
4111{
4112	int r;
4113
4114	/* save restore block */
4115	if (rdev->rlc.save_restore_obj) {
4116		r = radeon_bo_reserve(rdev->rlc.save_restore_obj, false);
4117		if (unlikely(r != 0))
4118			dev_warn(rdev->dev, "(%d) reserve RLC sr bo failed\n", r);
4119		radeon_bo_unpin(rdev->rlc.save_restore_obj);
4120		radeon_bo_unreserve(rdev->rlc.save_restore_obj);
4121
4122		radeon_bo_unref(&rdev->rlc.save_restore_obj);
4123		rdev->rlc.save_restore_obj = NULL;
4124	}
4125
4126	/* clear state block */
4127	if (rdev->rlc.clear_state_obj) {
4128		r = radeon_bo_reserve(rdev->rlc.clear_state_obj, false);
4129		if (unlikely(r != 0))
4130			dev_warn(rdev->dev, "(%d) reserve RLC c bo failed\n", r);
4131		radeon_bo_unpin(rdev->rlc.clear_state_obj);
4132		radeon_bo_unreserve(rdev->rlc.clear_state_obj);
4133
4134		radeon_bo_unref(&rdev->rlc.clear_state_obj);
4135		rdev->rlc.clear_state_obj = NULL;
4136	}
4137
4138	/* clear state block */
4139	if (rdev->rlc.cp_table_obj) {
4140		r = radeon_bo_reserve(rdev->rlc.cp_table_obj, false);
4141		if (unlikely(r != 0))
4142			dev_warn(rdev->dev, "(%d) reserve RLC cp table bo failed\n", r);
4143		radeon_bo_unpin(rdev->rlc.cp_table_obj);
4144		radeon_bo_unreserve(rdev->rlc.cp_table_obj);
4145
4146		radeon_bo_unref(&rdev->rlc.cp_table_obj);
4147		rdev->rlc.cp_table_obj = NULL;
4148	}
4149}
4150
4151#define CP_ME_TABLE_SIZE    96
4152
4153int sumo_rlc_init(struct radeon_device *rdev)
4154{
4155	const u32 *src_ptr;
4156	volatile u32 *dst_ptr;
4157	u32 dws, data, i, j, k, reg_num;
4158	u32 reg_list_num, reg_list_hdr_blk_index, reg_list_blk_index = 0;
4159	u64 reg_list_mc_addr;
4160	const struct cs_section_def *cs_data;
4161	int r;
4162
4163	src_ptr = rdev->rlc.reg_list;
4164	dws = rdev->rlc.reg_list_size;
4165	if (rdev->family >= CHIP_BONAIRE) {
4166		dws += (5 * 16) + 48 + 48 + 64;
4167	}
4168	cs_data = rdev->rlc.cs_data;
4169
4170	if (src_ptr) {
4171		/* save restore block */
4172		if (rdev->rlc.save_restore_obj == NULL) {
4173			r = radeon_bo_create(rdev, dws * 4, PAGE_SIZE, true,
4174					     RADEON_GEM_DOMAIN_VRAM, 0, NULL,
4175					     NULL, &rdev->rlc.save_restore_obj);
4176			if (r) {
4177				dev_warn(rdev->dev, "(%d) create RLC sr bo failed\n", r);
4178				return r;
4179			}
4180		}
4181
4182		r = radeon_bo_reserve(rdev->rlc.save_restore_obj, false);
4183		if (unlikely(r != 0)) {
4184			sumo_rlc_fini(rdev);
4185			return r;
4186		}
4187		r = radeon_bo_pin(rdev->rlc.save_restore_obj, RADEON_GEM_DOMAIN_VRAM,
4188				  &rdev->rlc.save_restore_gpu_addr);
4189		if (r) {
4190			radeon_bo_unreserve(rdev->rlc.save_restore_obj);
4191			dev_warn(rdev->dev, "(%d) pin RLC sr bo failed\n", r);
4192			sumo_rlc_fini(rdev);
4193			return r;
4194		}
4195
4196		r = radeon_bo_kmap(rdev->rlc.save_restore_obj, (void **)&rdev->rlc.sr_ptr);
4197		if (r) {
4198			dev_warn(rdev->dev, "(%d) map RLC sr bo failed\n", r);
4199			sumo_rlc_fini(rdev);
4200			return r;
4201		}
4202		/* write the sr buffer */
4203		dst_ptr = rdev->rlc.sr_ptr;
4204		if (rdev->family >= CHIP_TAHITI) {
4205			/* SI */
4206			for (i = 0; i < rdev->rlc.reg_list_size; i++)
4207				dst_ptr[i] = cpu_to_le32(src_ptr[i]);
4208		} else {
4209			/* ON/LN/TN */
4210			/* format:
4211			 * dw0: (reg2 << 16) | reg1
4212			 * dw1: reg1 save space
4213			 * dw2: reg2 save space
4214			 */
4215			for (i = 0; i < dws; i++) {
4216				data = src_ptr[i] >> 2;
4217				i++;
4218				if (i < dws)
4219					data |= (src_ptr[i] >> 2) << 16;
4220				j = (((i - 1) * 3) / 2);
4221				dst_ptr[j] = cpu_to_le32(data);
4222			}
4223			j = ((i * 3) / 2);
4224			dst_ptr[j] = cpu_to_le32(RLC_SAVE_RESTORE_LIST_END_MARKER);
4225		}
4226		radeon_bo_kunmap(rdev->rlc.save_restore_obj);
4227		radeon_bo_unreserve(rdev->rlc.save_restore_obj);
4228	}
4229
4230	if (cs_data) {
4231		/* clear state block */
4232		if (rdev->family >= CHIP_BONAIRE) {
4233			rdev->rlc.clear_state_size = dws = cik_get_csb_size(rdev);
4234		} else if (rdev->family >= CHIP_TAHITI) {
4235			rdev->rlc.clear_state_size = si_get_csb_size(rdev);
4236			dws = rdev->rlc.clear_state_size + (256 / 4);
4237		} else {
4238			reg_list_num = 0;
4239			dws = 0;
4240			for (i = 0; cs_data[i].section != NULL; i++) {
4241				for (j = 0; cs_data[i].section[j].extent != NULL; j++) {
4242					reg_list_num++;
4243					dws += cs_data[i].section[j].reg_count;
4244				}
4245			}
4246			reg_list_blk_index = (3 * reg_list_num + 2);
4247			dws += reg_list_blk_index;
4248			rdev->rlc.clear_state_size = dws;
4249		}
4250
4251		if (rdev->rlc.clear_state_obj == NULL) {
4252			r = radeon_bo_create(rdev, dws * 4, PAGE_SIZE, true,
4253					     RADEON_GEM_DOMAIN_VRAM, 0, NULL,
4254					     NULL, &rdev->rlc.clear_state_obj);
4255			if (r) {
4256				dev_warn(rdev->dev, "(%d) create RLC c bo failed\n", r);
4257				sumo_rlc_fini(rdev);
4258				return r;
4259			}
4260		}
4261		r = radeon_bo_reserve(rdev->rlc.clear_state_obj, false);
4262		if (unlikely(r != 0)) {
4263			sumo_rlc_fini(rdev);
4264			return r;
4265		}
4266		r = radeon_bo_pin(rdev->rlc.clear_state_obj, RADEON_GEM_DOMAIN_VRAM,
4267				  &rdev->rlc.clear_state_gpu_addr);
4268		if (r) {
4269			radeon_bo_unreserve(rdev->rlc.clear_state_obj);
4270			dev_warn(rdev->dev, "(%d) pin RLC c bo failed\n", r);
4271			sumo_rlc_fini(rdev);
4272			return r;
4273		}
4274
4275		r = radeon_bo_kmap(rdev->rlc.clear_state_obj, (void **)&rdev->rlc.cs_ptr);
4276		if (r) {
4277			dev_warn(rdev->dev, "(%d) map RLC c bo failed\n", r);
4278			sumo_rlc_fini(rdev);
4279			return r;
4280		}
4281		/* set up the cs buffer */
4282		dst_ptr = rdev->rlc.cs_ptr;
4283		if (rdev->family >= CHIP_BONAIRE) {
4284			cik_get_csb_buffer(rdev, dst_ptr);
4285		} else if (rdev->family >= CHIP_TAHITI) {
4286			reg_list_mc_addr = rdev->rlc.clear_state_gpu_addr + 256;
4287			dst_ptr[0] = cpu_to_le32(upper_32_bits(reg_list_mc_addr));
4288			dst_ptr[1] = cpu_to_le32(lower_32_bits(reg_list_mc_addr));
4289			dst_ptr[2] = cpu_to_le32(rdev->rlc.clear_state_size);
4290			si_get_csb_buffer(rdev, &dst_ptr[(256/4)]);
4291		} else {
4292			reg_list_hdr_blk_index = 0;
4293			reg_list_mc_addr = rdev->rlc.clear_state_gpu_addr + (reg_list_blk_index * 4);
4294			data = upper_32_bits(reg_list_mc_addr);
4295			dst_ptr[reg_list_hdr_blk_index] = cpu_to_le32(data);
4296			reg_list_hdr_blk_index++;
4297			for (i = 0; cs_data[i].section != NULL; i++) {
4298				for (j = 0; cs_data[i].section[j].extent != NULL; j++) {
4299					reg_num = cs_data[i].section[j].reg_count;
4300					data = reg_list_mc_addr & 0xffffffff;
4301					dst_ptr[reg_list_hdr_blk_index] = cpu_to_le32(data);
4302					reg_list_hdr_blk_index++;
4303
4304					data = (cs_data[i].section[j].reg_index * 4) & 0xffffffff;
4305					dst_ptr[reg_list_hdr_blk_index] = cpu_to_le32(data);
4306					reg_list_hdr_blk_index++;
4307
4308					data = 0x08000000 | (reg_num * 4);
4309					dst_ptr[reg_list_hdr_blk_index] = cpu_to_le32(data);
4310					reg_list_hdr_blk_index++;
4311
4312					for (k = 0; k < reg_num; k++) {
4313						data = cs_data[i].section[j].extent[k];
4314						dst_ptr[reg_list_blk_index + k] = cpu_to_le32(data);
4315					}
4316					reg_list_mc_addr += reg_num * 4;
4317					reg_list_blk_index += reg_num;
4318				}
4319			}
4320			dst_ptr[reg_list_hdr_blk_index] = cpu_to_le32(RLC_CLEAR_STATE_END_MARKER);
4321		}
4322		radeon_bo_kunmap(rdev->rlc.clear_state_obj);
4323		radeon_bo_unreserve(rdev->rlc.clear_state_obj);
4324	}
4325
4326	if (rdev->rlc.cp_table_size) {
4327		if (rdev->rlc.cp_table_obj == NULL) {
4328			r = radeon_bo_create(rdev, rdev->rlc.cp_table_size,
4329					     PAGE_SIZE, true,
4330					     RADEON_GEM_DOMAIN_VRAM, 0, NULL,
4331					     NULL, &rdev->rlc.cp_table_obj);
4332			if (r) {
4333				dev_warn(rdev->dev, "(%d) create RLC cp table bo failed\n", r);
4334				sumo_rlc_fini(rdev);
4335				return r;
4336			}
4337		}
4338
4339		r = radeon_bo_reserve(rdev->rlc.cp_table_obj, false);
4340		if (unlikely(r != 0)) {
4341			dev_warn(rdev->dev, "(%d) reserve RLC cp table bo failed\n", r);
4342			sumo_rlc_fini(rdev);
4343			return r;
4344		}
4345		r = radeon_bo_pin(rdev->rlc.cp_table_obj, RADEON_GEM_DOMAIN_VRAM,
4346				  &rdev->rlc.cp_table_gpu_addr);
4347		if (r) {
4348			radeon_bo_unreserve(rdev->rlc.cp_table_obj);
4349			dev_warn(rdev->dev, "(%d) pin RLC cp_table bo failed\n", r);
4350			sumo_rlc_fini(rdev);
4351			return r;
4352		}
4353		r = radeon_bo_kmap(rdev->rlc.cp_table_obj, (void **)&rdev->rlc.cp_table_ptr);
4354		if (r) {
4355			dev_warn(rdev->dev, "(%d) map RLC cp table bo failed\n", r);
4356			sumo_rlc_fini(rdev);
4357			return r;
4358		}
4359
4360		cik_init_cp_pg_table(rdev);
4361
4362		radeon_bo_kunmap(rdev->rlc.cp_table_obj);
4363		radeon_bo_unreserve(rdev->rlc.cp_table_obj);
4364
4365	}
4366
4367	return 0;
4368}
4369
4370static void evergreen_rlc_start(struct radeon_device *rdev)
4371{
4372	u32 mask = RLC_ENABLE;
4373
4374	if (rdev->flags & RADEON_IS_IGP) {
4375		mask |= GFX_POWER_GATING_ENABLE | GFX_POWER_GATING_SRC;
4376	}
4377
4378	WREG32(RLC_CNTL, mask);
4379}
4380
4381int evergreen_rlc_resume(struct radeon_device *rdev)
4382{
4383	u32 i;
4384	const __be32 *fw_data;
4385
4386	if (!rdev->rlc_fw)
4387		return -EINVAL;
4388
4389	r600_rlc_stop(rdev);
4390
4391	WREG32(RLC_HB_CNTL, 0);
4392
4393	if (rdev->flags & RADEON_IS_IGP) {
4394		if (rdev->family == CHIP_ARUBA) {
4395			u32 always_on_bitmap =
4396				3 | (3 << (16 * rdev->config.cayman.max_shader_engines));
4397			/* find out the number of active simds */
4398			u32 tmp = (RREG32(CC_GC_SHADER_PIPE_CONFIG) & 0xffff0000) >> 16;
4399			tmp |= 0xffffffff << rdev->config.cayman.max_simds_per_se;
4400			tmp = hweight32(~tmp);
4401			if (tmp == rdev->config.cayman.max_simds_per_se) {
4402				WREG32(TN_RLC_LB_ALWAYS_ACTIVE_SIMD_MASK, always_on_bitmap);
4403				WREG32(TN_RLC_LB_PARAMS, 0x00601004);
4404				WREG32(TN_RLC_LB_INIT_SIMD_MASK, 0xffffffff);
4405				WREG32(TN_RLC_LB_CNTR_INIT, 0x00000000);
4406				WREG32(TN_RLC_LB_CNTR_MAX, 0x00002000);
4407			}
4408		} else {
4409			WREG32(RLC_HB_WPTR_LSB_ADDR, 0);
4410			WREG32(RLC_HB_WPTR_MSB_ADDR, 0);
4411		}
4412		WREG32(TN_RLC_SAVE_AND_RESTORE_BASE, rdev->rlc.save_restore_gpu_addr >> 8);
4413		WREG32(TN_RLC_CLEAR_STATE_RESTORE_BASE, rdev->rlc.clear_state_gpu_addr >> 8);
4414	} else {
4415		WREG32(RLC_HB_BASE, 0);
4416		WREG32(RLC_HB_RPTR, 0);
4417		WREG32(RLC_HB_WPTR, 0);
4418		WREG32(RLC_HB_WPTR_LSB_ADDR, 0);
4419		WREG32(RLC_HB_WPTR_MSB_ADDR, 0);
4420	}
4421	WREG32(RLC_MC_CNTL, 0);
4422	WREG32(RLC_UCODE_CNTL, 0);
4423
4424	fw_data = (const __be32 *)rdev->rlc_fw->data;
4425	if (rdev->family >= CHIP_ARUBA) {
4426		for (i = 0; i < ARUBA_RLC_UCODE_SIZE; i++) {
4427			WREG32(RLC_UCODE_ADDR, i);
4428			WREG32(RLC_UCODE_DATA, be32_to_cpup(fw_data++));
4429		}
4430	} else if (rdev->family >= CHIP_CAYMAN) {
4431		for (i = 0; i < CAYMAN_RLC_UCODE_SIZE; i++) {
4432			WREG32(RLC_UCODE_ADDR, i);
4433			WREG32(RLC_UCODE_DATA, be32_to_cpup(fw_data++));
4434		}
4435	} else {
4436		for (i = 0; i < EVERGREEN_RLC_UCODE_SIZE; i++) {
4437			WREG32(RLC_UCODE_ADDR, i);
4438			WREG32(RLC_UCODE_DATA, be32_to_cpup(fw_data++));
4439		}
4440	}
4441	WREG32(RLC_UCODE_ADDR, 0);
4442
4443	evergreen_rlc_start(rdev);
4444
4445	return 0;
4446}
4447
4448/* Interrupts */
4449
4450u32 evergreen_get_vblank_counter(struct radeon_device *rdev, int crtc)
4451{
4452	if (crtc >= rdev->num_crtc)
4453		return 0;
4454	else
4455		return RREG32(CRTC_STATUS_FRAME_COUNT + crtc_offsets[crtc]);
4456}
4457
4458void evergreen_disable_interrupt_state(struct radeon_device *rdev)
4459{
4460	int i;
4461	u32 tmp;
4462
4463	if (rdev->family >= CHIP_CAYMAN) {
4464		cayman_cp_int_cntl_setup(rdev, 0,
4465					 CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE);
4466		cayman_cp_int_cntl_setup(rdev, 1, 0);
4467		cayman_cp_int_cntl_setup(rdev, 2, 0);
4468		tmp = RREG32(CAYMAN_DMA1_CNTL) & ~TRAP_ENABLE;
4469		WREG32(CAYMAN_DMA1_CNTL, tmp);
4470	} else
4471		WREG32(CP_INT_CNTL, CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE);
4472	tmp = RREG32(DMA_CNTL) & ~TRAP_ENABLE;
4473	WREG32(DMA_CNTL, tmp);
4474	WREG32(GRBM_INT_CNTL, 0);
4475	WREG32(SRBM_INT_CNTL, 0);
4476	for (i = 0; i < rdev->num_crtc; i++)
4477		WREG32(INT_MASK + crtc_offsets[i], 0);
4478	for (i = 0; i < rdev->num_crtc; i++)
4479		WREG32(GRPH_INT_CONTROL + crtc_offsets[i], 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4480
4481	/* only one DAC on DCE5 */
4482	if (!ASIC_IS_DCE5(rdev))
4483		WREG32(DACA_AUTODETECT_INT_CONTROL, 0);
4484	WREG32(DACB_AUTODETECT_INT_CONTROL, 0);
4485
4486	for (i = 0; i < 6; i++)
4487		WREG32_AND(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_POLARITY);
 
 
 
 
 
 
 
 
 
 
 
4488}
4489
4490/* Note that the order we write back regs here is important */
4491int evergreen_irq_set(struct radeon_device *rdev)
4492{
4493	int i;
4494	u32 cp_int_cntl = CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE;
4495	u32 cp_int_cntl1 = 0, cp_int_cntl2 = 0;
 
 
4496	u32 grbm_int_cntl = 0;
 
4497	u32 dma_cntl, dma_cntl1 = 0;
4498	u32 thermal_int = 0;
4499
4500	if (!rdev->irq.installed) {
4501		WARN(1, "Can't enable IRQ/MSI because no handler is installed\n");
4502		return -EINVAL;
4503	}
4504	/* don't enable anything if the ih is disabled */
4505	if (!rdev->ih.enabled) {
4506		r600_disable_interrupts(rdev);
4507		/* force the active interrupt state to all disabled */
4508		evergreen_disable_interrupt_state(rdev);
4509		return 0;
4510	}
4511
 
 
 
 
 
 
4512	if (rdev->family == CHIP_ARUBA)
4513		thermal_int = RREG32(TN_CG_THERMAL_INT_CTRL) &
4514			~(THERM_INT_MASK_HIGH | THERM_INT_MASK_LOW);
4515	else
4516		thermal_int = RREG32(CG_THERMAL_INT) &
4517			~(THERM_INT_MASK_HIGH | THERM_INT_MASK_LOW);
4518
 
 
 
 
 
 
 
4519	dma_cntl = RREG32(DMA_CNTL) & ~TRAP_ENABLE;
4520
4521	if (rdev->family >= CHIP_CAYMAN) {
4522		/* enable CP interrupts on all rings */
4523		if (atomic_read(&rdev->irq.ring_int[RADEON_RING_TYPE_GFX_INDEX])) {
4524			DRM_DEBUG("evergreen_irq_set: sw int gfx\n");
4525			cp_int_cntl |= TIME_STAMP_INT_ENABLE;
4526		}
4527		if (atomic_read(&rdev->irq.ring_int[CAYMAN_RING_TYPE_CP1_INDEX])) {
4528			DRM_DEBUG("evergreen_irq_set: sw int cp1\n");
4529			cp_int_cntl1 |= TIME_STAMP_INT_ENABLE;
4530		}
4531		if (atomic_read(&rdev->irq.ring_int[CAYMAN_RING_TYPE_CP2_INDEX])) {
4532			DRM_DEBUG("evergreen_irq_set: sw int cp2\n");
4533			cp_int_cntl2 |= TIME_STAMP_INT_ENABLE;
4534		}
4535	} else {
4536		if (atomic_read(&rdev->irq.ring_int[RADEON_RING_TYPE_GFX_INDEX])) {
4537			DRM_DEBUG("evergreen_irq_set: sw int gfx\n");
4538			cp_int_cntl |= RB_INT_ENABLE;
4539			cp_int_cntl |= TIME_STAMP_INT_ENABLE;
4540		}
4541	}
4542
4543	if (atomic_read(&rdev->irq.ring_int[R600_RING_TYPE_DMA_INDEX])) {
4544		DRM_DEBUG("r600_irq_set: sw int dma\n");
4545		dma_cntl |= TRAP_ENABLE;
4546	}
4547
4548	if (rdev->family >= CHIP_CAYMAN) {
4549		dma_cntl1 = RREG32(CAYMAN_DMA1_CNTL) & ~TRAP_ENABLE;
4550		if (atomic_read(&rdev->irq.ring_int[CAYMAN_RING_TYPE_DMA1_INDEX])) {
4551			DRM_DEBUG("r600_irq_set: sw int dma1\n");
4552			dma_cntl1 |= TRAP_ENABLE;
4553		}
4554	}
4555
4556	if (rdev->irq.dpm_thermal) {
4557		DRM_DEBUG("dpm thermal\n");
4558		thermal_int |= THERM_INT_MASK_HIGH | THERM_INT_MASK_LOW;
4559	}
4560
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4561	if (rdev->family >= CHIP_CAYMAN) {
4562		cayman_cp_int_cntl_setup(rdev, 0, cp_int_cntl);
4563		cayman_cp_int_cntl_setup(rdev, 1, cp_int_cntl1);
4564		cayman_cp_int_cntl_setup(rdev, 2, cp_int_cntl2);
4565	} else
4566		WREG32(CP_INT_CNTL, cp_int_cntl);
4567
4568	WREG32(DMA_CNTL, dma_cntl);
4569
4570	if (rdev->family >= CHIP_CAYMAN)
4571		WREG32(CAYMAN_DMA1_CNTL, dma_cntl1);
4572
4573	WREG32(GRBM_INT_CNTL, grbm_int_cntl);
4574
4575	for (i = 0; i < rdev->num_crtc; i++) {
4576		radeon_irq_kms_set_irq_n_enabled(
4577		    rdev, INT_MASK + crtc_offsets[i],
4578		    VBLANK_INT_MASK,
4579		    rdev->irq.crtc_vblank_int[i] ||
4580		    atomic_read(&rdev->irq.pflip[i]), "vblank", i);
4581	}
4582
4583	for (i = 0; i < rdev->num_crtc; i++)
4584		WREG32(GRPH_INT_CONTROL + crtc_offsets[i], GRPH_PFLIP_INT_MASK);
4585
4586	for (i = 0; i < 6; i++) {
4587		radeon_irq_kms_set_irq_n_enabled(
4588		    rdev, DC_HPDx_INT_CONTROL(i),
4589		    DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN,
4590		    rdev->irq.hpd[i], "HPD", i);
4591	}
4592
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4593	if (rdev->family == CHIP_ARUBA)
4594		WREG32(TN_CG_THERMAL_INT_CTRL, thermal_int);
4595	else
4596		WREG32(CG_THERMAL_INT, thermal_int);
4597
4598	for (i = 0; i < 6; i++) {
4599		radeon_irq_kms_set_irq_n_enabled(
4600		    rdev, AFMT_AUDIO_PACKET_CONTROL + crtc_offsets[i],
4601		    AFMT_AZ_FORMAT_WTRIG_MASK,
4602		    rdev->irq.afmt[i], "HDMI", i);
4603	}
4604
4605	/* posting read */
4606	RREG32(SRBM_STATUS);
4607
4608	return 0;
4609}
4610
4611/* Note that the order we write back regs here is important */
4612static void evergreen_irq_ack(struct radeon_device *rdev)
4613{
4614	int i, j;
4615	u32 *grph_int = rdev->irq.stat_regs.evergreen.grph_int;
4616	u32 *disp_int = rdev->irq.stat_regs.evergreen.disp_int;
4617	u32 *afmt_status = rdev->irq.stat_regs.evergreen.afmt_status;
4618
4619	for (i = 0; i < 6; i++) {
4620		disp_int[i] = RREG32(evergreen_disp_int_status[i]);
4621		afmt_status[i] = RREG32(AFMT_STATUS + crtc_offsets[i]);
4622		if (i < rdev->num_crtc)
4623			grph_int[i] = RREG32(GRPH_INT_STATUS + crtc_offsets[i]);
4624	}
4625
4626	/* We write back each interrupt register in pairs of two */
4627	for (i = 0; i < rdev->num_crtc; i += 2) {
4628		for (j = i; j < (i + 2); j++) {
4629			if (grph_int[j] & GRPH_PFLIP_INT_OCCURRED)
4630				WREG32(GRPH_INT_STATUS + crtc_offsets[j],
4631				       GRPH_PFLIP_INT_CLEAR);
4632		}
4633
4634		for (j = i; j < (i + 2); j++) {
4635			if (disp_int[j] & LB_D1_VBLANK_INTERRUPT)
4636				WREG32(VBLANK_STATUS + crtc_offsets[j],
4637				       VBLANK_ACK);
4638			if (disp_int[j] & LB_D1_VLINE_INTERRUPT)
4639				WREG32(VLINE_STATUS + crtc_offsets[j],
4640				       VLINE_ACK);
4641		}
4642	}
4643
4644	for (i = 0; i < 6; i++) {
4645		if (disp_int[i] & DC_HPD1_INTERRUPT)
4646			WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_ACK);
4647	}
4648
4649	for (i = 0; i < 6; i++) {
4650		if (disp_int[i] & DC_HPD1_RX_INTERRUPT)
4651			WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_RX_INT_ACK);
4652	}
4653
4654	for (i = 0; i < 6; i++) {
4655		if (afmt_status[i] & AFMT_AZ_FORMAT_WTRIG)
4656			WREG32_OR(AFMT_AUDIO_PACKET_CONTROL + crtc_offsets[i],
4657				  AFMT_AZ_FORMAT_WTRIG_ACK);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4658	}
4659}
4660
4661static void evergreen_irq_disable(struct radeon_device *rdev)
4662{
4663	r600_disable_interrupts(rdev);
4664	/* Wait and acknowledge irq */
4665	mdelay(1);
4666	evergreen_irq_ack(rdev);
4667	evergreen_disable_interrupt_state(rdev);
4668}
4669
4670void evergreen_irq_suspend(struct radeon_device *rdev)
4671{
4672	evergreen_irq_disable(rdev);
4673	r600_rlc_stop(rdev);
4674}
4675
4676static u32 evergreen_get_ih_wptr(struct radeon_device *rdev)
4677{
4678	u32 wptr, tmp;
4679
4680	if (rdev->wb.enabled)
4681		wptr = le32_to_cpu(rdev->wb.wb[R600_WB_IH_WPTR_OFFSET/4]);
4682	else
4683		wptr = RREG32(IH_RB_WPTR);
4684
4685	if (wptr & RB_OVERFLOW) {
4686		wptr &= ~RB_OVERFLOW;
4687		/* When a ring buffer overflow happen start parsing interrupt
4688		 * from the last not overwritten vector (wptr + 16). Hopefully
4689		 * this should allow us to catchup.
4690		 */
4691		dev_warn(rdev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n",
4692			 wptr, rdev->ih.rptr, (wptr + 16) & rdev->ih.ptr_mask);
4693		rdev->ih.rptr = (wptr + 16) & rdev->ih.ptr_mask;
4694		tmp = RREG32(IH_RB_CNTL);
4695		tmp |= IH_WPTR_OVERFLOW_CLEAR;
4696		WREG32(IH_RB_CNTL, tmp);
4697	}
4698	return (wptr & rdev->ih.ptr_mask);
4699}
4700
4701int evergreen_irq_process(struct radeon_device *rdev)
4702{
4703	u32 *disp_int = rdev->irq.stat_regs.evergreen.disp_int;
4704	u32 *afmt_status = rdev->irq.stat_regs.evergreen.afmt_status;
4705	u32 crtc_idx, hpd_idx, afmt_idx;
4706	u32 mask;
4707	u32 wptr;
4708	u32 rptr;
4709	u32 src_id, src_data;
4710	u32 ring_index;
4711	bool queue_hotplug = false;
4712	bool queue_hdmi = false;
4713	bool queue_dp = false;
4714	bool queue_thermal = false;
4715	u32 status, addr;
4716	const char *event_name;
4717
4718	if (!rdev->ih.enabled || rdev->shutdown)
4719		return IRQ_NONE;
4720
4721	wptr = evergreen_get_ih_wptr(rdev);
4722
4723restart_ih:
4724	/* is somebody else already processing irqs? */
4725	if (atomic_xchg(&rdev->ih.lock, 1))
4726		return IRQ_NONE;
4727
4728	rptr = rdev->ih.rptr;
4729	DRM_DEBUG("evergreen_irq_process start: rptr %d, wptr %d\n", rptr, wptr);
4730
4731	/* Order reading of wptr vs. reading of IH ring data */
4732	rmb();
4733
4734	/* display interrupts */
4735	evergreen_irq_ack(rdev);
4736
4737	while (rptr != wptr) {
4738		/* wptr/rptr are in bytes! */
4739		ring_index = rptr / 4;
4740		src_id =  le32_to_cpu(rdev->ih.ring[ring_index]) & 0xff;
4741		src_data = le32_to_cpu(rdev->ih.ring[ring_index + 1]) & 0xfffffff;
4742
4743		switch (src_id) {
4744		case 1: /* D1 vblank/vline */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4745		case 2: /* D2 vblank/vline */
4746		case 3: /* D3 vblank/vline */
4747		case 4: /* D4 vblank/vline */
4748		case 5: /* D5 vblank/vline */
4749		case 6: /* D6 vblank/vline */
4750			crtc_idx = src_id - 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4751
4752			if (src_data == 0) { /* vblank */
4753				mask = LB_D1_VBLANK_INTERRUPT;
4754				event_name = "vblank";
 
 
 
 
 
 
 
 
 
 
 
4755
4756				if (rdev->irq.crtc_vblank_int[crtc_idx]) {
4757					drm_handle_vblank(rdev->ddev, crtc_idx);
4758					rdev->pm.vblank_sync = true;
4759					wake_up(&rdev->irq.vblank_queue);
4760				}
4761				if (atomic_read(&rdev->irq.pflip[crtc_idx])) {
4762					radeon_crtc_handle_vblank(rdev,
4763								  crtc_idx);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4764				}
 
 
 
 
4765
4766			} else if (src_data == 1) { /* vline */
4767				mask = LB_D1_VLINE_INTERRUPT;
4768				event_name = "vline";
4769			} else {
4770				DRM_DEBUG("Unhandled interrupt: %d %d\n",
4771					  src_id, src_data);
 
 
 
 
 
4772				break;
4773			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4774
4775			if (!(disp_int[crtc_idx] & mask)) {
4776				DRM_DEBUG("IH: D%d %s - IH event w/o asserted irq bit?\n",
4777					  crtc_idx + 1, event_name);
 
4778			}
 
 
 
 
 
 
4779
4780			disp_int[crtc_idx] &= ~mask;
4781			DRM_DEBUG("IH: D%d %s\n", crtc_idx + 1, event_name);
 
 
 
 
 
 
 
4782
 
 
 
 
 
 
 
 
 
 
 
 
 
4783			break;
4784		case 8: /* D1 page flip */
4785		case 10: /* D2 page flip */
4786		case 12: /* D3 page flip */
4787		case 14: /* D4 page flip */
4788		case 16: /* D5 page flip */
4789		case 18: /* D6 page flip */
4790			DRM_DEBUG("IH: D%d flip\n", ((src_id - 8) >> 1) + 1);
4791			if (radeon_use_pflipirq > 0)
4792				radeon_crtc_handle_flip(rdev, (src_id - 8) >> 1);
4793			break;
4794		case 42: /* HPD hotplug */
4795			if (src_data <= 5) {
4796				hpd_idx = src_data;
4797				mask = DC_HPD1_INTERRUPT;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4798				queue_hotplug = true;
4799				event_name = "HPD";
 
 
 
 
 
 
 
 
 
 
 
 
4800
4801			} else if (src_data <= 11) {
4802				hpd_idx = src_data - 6;
4803				mask = DC_HPD1_RX_INTERRUPT;
4804				queue_dp = true;
4805				event_name = "HPD_RX";
 
 
 
 
4806
4807			} else {
4808				DRM_DEBUG("Unhandled interrupt: %d %d\n",
4809					  src_id, src_data);
4810				break;
4811			}
 
 
 
 
 
 
 
 
 
 
4812
4813			if (!(disp_int[hpd_idx] & mask))
4814				DRM_DEBUG("IH: IH event w/o asserted irq bit?\n");
 
 
 
 
 
4815
4816			disp_int[hpd_idx] &= ~mask;
4817			DRM_DEBUG("IH: %s%d\n", event_name, hpd_idx + 1);
 
 
 
 
 
4818
 
 
 
 
 
 
 
 
4819			break;
4820		case 44: /* hdmi */
4821			afmt_idx = src_data;
4822			if (!(afmt_status[afmt_idx] & AFMT_AZ_FORMAT_WTRIG))
4823				DRM_DEBUG("IH: IH event w/o asserted irq bit?\n");
4824
4825			if (afmt_idx > 5) {
4826				DRM_ERROR("Unhandled interrupt: %d %d\n",
4827					  src_id, src_data);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4828				break;
4829			}
4830			afmt_status[afmt_idx] &= ~AFMT_AZ_FORMAT_WTRIG;
4831			queue_hdmi = true;
4832			DRM_DEBUG("IH: HDMI%d\n", afmt_idx + 1);
4833			break;
4834		case 96:
4835			DRM_ERROR("SRBM_READ_ERROR: 0x%x\n", RREG32(SRBM_READ_ERROR));
4836			WREG32(SRBM_INT_ACK, 0x1);
4837			break;
4838		case 124: /* UVD */
4839			DRM_DEBUG("IH: UVD int: 0x%08x\n", src_data);
4840			radeon_fence_process(rdev, R600_RING_TYPE_UVD_INDEX);
4841			break;
4842		case 146:
4843		case 147:
4844			addr = RREG32(VM_CONTEXT1_PROTECTION_FAULT_ADDR);
4845			status = RREG32(VM_CONTEXT1_PROTECTION_FAULT_STATUS);
4846			/* reset addr and status */
4847			WREG32_P(VM_CONTEXT1_CNTL2, 1, ~1);
4848			if (addr == 0x0 && status == 0x0)
4849				break;
4850			dev_err(rdev->dev, "GPU fault detected: %d 0x%08x\n", src_id, src_data);
4851			dev_err(rdev->dev, "  VM_CONTEXT1_PROTECTION_FAULT_ADDR   0x%08X\n",
4852				addr);
4853			dev_err(rdev->dev, "  VM_CONTEXT1_PROTECTION_FAULT_STATUS 0x%08X\n",
4854				status);
4855			cayman_vm_decode_fault(rdev, status, addr);
4856			break;
4857		case 176: /* CP_INT in ring buffer */
4858		case 177: /* CP_INT in IB1 */
4859		case 178: /* CP_INT in IB2 */
4860			DRM_DEBUG("IH: CP int: 0x%08x\n", src_data);
4861			radeon_fence_process(rdev, RADEON_RING_TYPE_GFX_INDEX);
4862			break;
4863		case 181: /* CP EOP event */
4864			DRM_DEBUG("IH: CP EOP\n");
4865			if (rdev->family >= CHIP_CAYMAN) {
4866				switch (src_data) {
4867				case 0:
4868					radeon_fence_process(rdev, RADEON_RING_TYPE_GFX_INDEX);
4869					break;
4870				case 1:
4871					radeon_fence_process(rdev, CAYMAN_RING_TYPE_CP1_INDEX);
4872					break;
4873				case 2:
4874					radeon_fence_process(rdev, CAYMAN_RING_TYPE_CP2_INDEX);
4875					break;
4876				}
4877			} else
4878				radeon_fence_process(rdev, RADEON_RING_TYPE_GFX_INDEX);
4879			break;
4880		case 224: /* DMA trap event */
4881			DRM_DEBUG("IH: DMA trap\n");
4882			radeon_fence_process(rdev, R600_RING_TYPE_DMA_INDEX);
4883			break;
4884		case 230: /* thermal low to high */
4885			DRM_DEBUG("IH: thermal low to high\n");
4886			rdev->pm.dpm.thermal.high_to_low = false;
4887			queue_thermal = true;
4888			break;
4889		case 231: /* thermal high to low */
4890			DRM_DEBUG("IH: thermal high to low\n");
4891			rdev->pm.dpm.thermal.high_to_low = true;
4892			queue_thermal = true;
4893			break;
4894		case 233: /* GUI IDLE */
4895			DRM_DEBUG("IH: GUI idle\n");
4896			break;
4897		case 244: /* DMA trap event */
4898			if (rdev->family >= CHIP_CAYMAN) {
4899				DRM_DEBUG("IH: DMA1 trap\n");
4900				radeon_fence_process(rdev, CAYMAN_RING_TYPE_DMA1_INDEX);
4901			}
4902			break;
4903		default:
4904			DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data);
4905			break;
4906		}
4907
4908		/* wptr/rptr are in bytes! */
4909		rptr += 16;
4910		rptr &= rdev->ih.ptr_mask;
4911		WREG32(IH_RB_RPTR, rptr);
4912	}
4913	if (queue_dp)
4914		schedule_work(&rdev->dp_work);
4915	if (queue_hotplug)
4916		schedule_delayed_work(&rdev->hotplug_work, 0);
4917	if (queue_hdmi)
4918		schedule_work(&rdev->audio_work);
4919	if (queue_thermal && rdev->pm.dpm_enabled)
4920		schedule_work(&rdev->pm.dpm.thermal.work);
4921	rdev->ih.rptr = rptr;
4922	atomic_set(&rdev->ih.lock, 0);
4923
4924	/* make sure wptr hasn't changed while processing */
4925	wptr = evergreen_get_ih_wptr(rdev);
4926	if (wptr != rptr)
4927		goto restart_ih;
4928
4929	return IRQ_HANDLED;
4930}
4931
4932static void evergreen_uvd_init(struct radeon_device *rdev)
4933{
4934	int r;
4935
4936	if (!rdev->has_uvd)
4937		return;
4938
4939	r = radeon_uvd_init(rdev);
4940	if (r) {
4941		dev_err(rdev->dev, "failed UVD (%d) init.\n", r);
4942		/*
4943		 * At this point rdev->uvd.vcpu_bo is NULL which trickles down
4944		 * to early fails uvd_v2_2_resume() and thus nothing happens
4945		 * there. So it is pointless to try to go through that code
4946		 * hence why we disable uvd here.
4947		 */
4948		rdev->has_uvd = 0;
4949		return;
4950	}
4951	rdev->ring[R600_RING_TYPE_UVD_INDEX].ring_obj = NULL;
4952	r600_ring_init(rdev, &rdev->ring[R600_RING_TYPE_UVD_INDEX], 4096);
4953}
4954
4955static void evergreen_uvd_start(struct radeon_device *rdev)
4956{
4957	int r;
4958
4959	if (!rdev->has_uvd)
4960		return;
4961
4962	r = uvd_v2_2_resume(rdev);
4963	if (r) {
4964		dev_err(rdev->dev, "failed UVD resume (%d).\n", r);
4965		goto error;
4966	}
4967	r = radeon_fence_driver_start_ring(rdev, R600_RING_TYPE_UVD_INDEX);
4968	if (r) {
4969		dev_err(rdev->dev, "failed initializing UVD fences (%d).\n", r);
4970		goto error;
4971	}
4972	return;
4973
4974error:
4975	rdev->ring[R600_RING_TYPE_UVD_INDEX].ring_size = 0;
4976}
4977
4978static void evergreen_uvd_resume(struct radeon_device *rdev)
4979{
4980	struct radeon_ring *ring;
4981	int r;
4982
4983	if (!rdev->has_uvd || !rdev->ring[R600_RING_TYPE_UVD_INDEX].ring_size)
4984		return;
4985
4986	ring = &rdev->ring[R600_RING_TYPE_UVD_INDEX];
4987	r = radeon_ring_init(rdev, ring, ring->ring_size, 0, PACKET0(UVD_NO_OP, 0));
4988	if (r) {
4989		dev_err(rdev->dev, "failed initializing UVD ring (%d).\n", r);
4990		return;
4991	}
4992	r = uvd_v1_0_init(rdev);
4993	if (r) {
4994		dev_err(rdev->dev, "failed initializing UVD (%d).\n", r);
4995		return;
4996	}
4997}
4998
4999static int evergreen_startup(struct radeon_device *rdev)
5000{
5001	struct radeon_ring *ring;
5002	int r;
5003
5004	/* enable pcie gen2 link */
5005	evergreen_pcie_gen2_enable(rdev);
5006	/* enable aspm */
5007	evergreen_program_aspm(rdev);
5008
5009	/* scratch needs to be initialized before MC */
5010	r = r600_vram_scratch_init(rdev);
5011	if (r)
5012		return r;
5013
5014	evergreen_mc_program(rdev);
5015
5016	if (ASIC_IS_DCE5(rdev) && !rdev->pm.dpm_enabled) {
5017		r = ni_mc_load_microcode(rdev);
5018		if (r) {
5019			DRM_ERROR("Failed to load MC firmware!\n");
5020			return r;
5021		}
5022	}
5023
5024	if (rdev->flags & RADEON_IS_AGP) {
5025		evergreen_agp_enable(rdev);
5026	} else {
5027		r = evergreen_pcie_gart_enable(rdev);
5028		if (r)
5029			return r;
5030	}
5031	evergreen_gpu_init(rdev);
5032
5033	/* allocate rlc buffers */
5034	if (rdev->flags & RADEON_IS_IGP) {
5035		rdev->rlc.reg_list = sumo_rlc_save_restore_register_list;
5036		rdev->rlc.reg_list_size =
5037			(u32)ARRAY_SIZE(sumo_rlc_save_restore_register_list);
5038		rdev->rlc.cs_data = evergreen_cs_data;
5039		r = sumo_rlc_init(rdev);
5040		if (r) {
5041			DRM_ERROR("Failed to init rlc BOs!\n");
5042			return r;
5043		}
5044	}
5045
5046	/* allocate wb buffer */
5047	r = radeon_wb_init(rdev);
5048	if (r)
5049		return r;
5050
5051	r = radeon_fence_driver_start_ring(rdev, RADEON_RING_TYPE_GFX_INDEX);
5052	if (r) {
5053		dev_err(rdev->dev, "failed initializing CP fences (%d).\n", r);
5054		return r;
5055	}
5056
5057	r = radeon_fence_driver_start_ring(rdev, R600_RING_TYPE_DMA_INDEX);
5058	if (r) {
5059		dev_err(rdev->dev, "failed initializing DMA fences (%d).\n", r);
5060		return r;
5061	}
5062
5063	evergreen_uvd_start(rdev);
5064
5065	/* Enable IRQ */
5066	if (!rdev->irq.installed) {
5067		r = radeon_irq_kms_init(rdev);
5068		if (r)
5069			return r;
5070	}
5071
5072	r = r600_irq_init(rdev);
5073	if (r) {
5074		DRM_ERROR("radeon: IH init failed (%d).\n", r);
5075		radeon_irq_kms_fini(rdev);
5076		return r;
5077	}
5078	evergreen_irq_set(rdev);
5079
5080	ring = &rdev->ring[RADEON_RING_TYPE_GFX_INDEX];
5081	r = radeon_ring_init(rdev, ring, ring->ring_size, RADEON_WB_CP_RPTR_OFFSET,
5082			     RADEON_CP_PACKET2);
5083	if (r)
5084		return r;
5085
5086	ring = &rdev->ring[R600_RING_TYPE_DMA_INDEX];
5087	r = radeon_ring_init(rdev, ring, ring->ring_size, R600_WB_DMA_RPTR_OFFSET,
5088			     DMA_PACKET(DMA_PACKET_NOP, 0, 0));
5089	if (r)
5090		return r;
5091
5092	r = evergreen_cp_load_microcode(rdev);
5093	if (r)
5094		return r;
5095	r = evergreen_cp_resume(rdev);
5096	if (r)
5097		return r;
5098	r = r600_dma_resume(rdev);
5099	if (r)
5100		return r;
5101
5102	evergreen_uvd_resume(rdev);
5103
5104	r = radeon_ib_pool_init(rdev);
5105	if (r) {
5106		dev_err(rdev->dev, "IB initialization failed (%d).\n", r);
5107		return r;
5108	}
5109
5110	r = radeon_audio_init(rdev);
5111	if (r) {
5112		DRM_ERROR("radeon: audio init failed\n");
5113		return r;
5114	}
5115
5116	return 0;
5117}
5118
5119int evergreen_resume(struct radeon_device *rdev)
5120{
5121	int r;
5122
5123	/* reset the asic, the gfx blocks are often in a bad state
5124	 * after the driver is unloaded or after a resume
5125	 */
5126	if (radeon_asic_reset(rdev))
5127		dev_warn(rdev->dev, "GPU reset failed !\n");
5128	/* Do not reset GPU before posting, on rv770 hw unlike on r500 hw,
5129	 * posting will perform necessary task to bring back GPU into good
5130	 * shape.
5131	 */
5132	/* post card */
5133	atom_asic_init(rdev->mode_info.atom_context);
5134
5135	/* init golden registers */
5136	evergreen_init_golden_registers(rdev);
5137
5138	if (rdev->pm.pm_method == PM_METHOD_DPM)
5139		radeon_pm_resume(rdev);
5140
5141	rdev->accel_working = true;
5142	r = evergreen_startup(rdev);
5143	if (r) {
5144		DRM_ERROR("evergreen startup failed on resume\n");
5145		rdev->accel_working = false;
5146		return r;
5147	}
5148
5149	return r;
5150
5151}
5152
5153int evergreen_suspend(struct radeon_device *rdev)
5154{
5155	radeon_pm_suspend(rdev);
5156	radeon_audio_fini(rdev);
5157	if (rdev->has_uvd) {
5158		uvd_v1_0_fini(rdev);
5159		radeon_uvd_suspend(rdev);
5160	}
5161	r700_cp_stop(rdev);
5162	r600_dma_stop(rdev);
5163	evergreen_irq_suspend(rdev);
5164	radeon_wb_disable(rdev);
5165	evergreen_pcie_gart_disable(rdev);
5166
5167	return 0;
5168}
5169
5170/* Plan is to move initialization in that function and use
5171 * helper function so that radeon_device_init pretty much
5172 * do nothing more than calling asic specific function. This
5173 * should also allow to remove a bunch of callback function
5174 * like vram_info.
5175 */
5176int evergreen_init(struct radeon_device *rdev)
5177{
5178	int r;
5179
5180	/* Read BIOS */
5181	if (!radeon_get_bios(rdev)) {
5182		if (ASIC_IS_AVIVO(rdev))
5183			return -EINVAL;
5184	}
5185	/* Must be an ATOMBIOS */
5186	if (!rdev->is_atom_bios) {
5187		dev_err(rdev->dev, "Expecting atombios for evergreen GPU\n");
5188		return -EINVAL;
5189	}
5190	r = radeon_atombios_init(rdev);
5191	if (r)
5192		return r;
5193	/* reset the asic, the gfx blocks are often in a bad state
5194	 * after the driver is unloaded or after a resume
5195	 */
5196	if (radeon_asic_reset(rdev))
5197		dev_warn(rdev->dev, "GPU reset failed !\n");
5198	/* Post card if necessary */
5199	if (!radeon_card_posted(rdev)) {
5200		if (!rdev->bios) {
5201			dev_err(rdev->dev, "Card not posted and no BIOS - ignoring\n");
5202			return -EINVAL;
5203		}
5204		DRM_INFO("GPU not posted. posting now...\n");
5205		atom_asic_init(rdev->mode_info.atom_context);
5206	}
5207	/* init golden registers */
5208	evergreen_init_golden_registers(rdev);
5209	/* Initialize scratch registers */
5210	r600_scratch_init(rdev);
5211	/* Initialize surface registers */
5212	radeon_surface_init(rdev);
5213	/* Initialize clocks */
5214	radeon_get_clock_info(rdev->ddev);
5215	/* Fence driver */
5216	r = radeon_fence_driver_init(rdev);
5217	if (r)
5218		return r;
5219	/* initialize AGP */
5220	if (rdev->flags & RADEON_IS_AGP) {
5221		r = radeon_agp_init(rdev);
5222		if (r)
5223			radeon_agp_disable(rdev);
5224	}
5225	/* initialize memory controller */
5226	r = evergreen_mc_init(rdev);
5227	if (r)
5228		return r;
5229	/* Memory manager */
5230	r = radeon_bo_init(rdev);
5231	if (r)
5232		return r;
5233
5234	if (ASIC_IS_DCE5(rdev)) {
5235		if (!rdev->me_fw || !rdev->pfp_fw || !rdev->rlc_fw || !rdev->mc_fw) {
5236			r = ni_init_microcode(rdev);
5237			if (r) {
5238				DRM_ERROR("Failed to load firmware!\n");
5239				return r;
5240			}
5241		}
5242	} else {
5243		if (!rdev->me_fw || !rdev->pfp_fw || !rdev->rlc_fw) {
5244			r = r600_init_microcode(rdev);
5245			if (r) {
5246				DRM_ERROR("Failed to load firmware!\n");
5247				return r;
5248			}
5249		}
5250	}
5251
5252	/* Initialize power management */
5253	radeon_pm_init(rdev);
5254
5255	rdev->ring[RADEON_RING_TYPE_GFX_INDEX].ring_obj = NULL;
5256	r600_ring_init(rdev, &rdev->ring[RADEON_RING_TYPE_GFX_INDEX], 1024 * 1024);
5257
5258	rdev->ring[R600_RING_TYPE_DMA_INDEX].ring_obj = NULL;
5259	r600_ring_init(rdev, &rdev->ring[R600_RING_TYPE_DMA_INDEX], 64 * 1024);
5260
5261	evergreen_uvd_init(rdev);
5262
5263	rdev->ih.ring_obj = NULL;
5264	r600_ih_ring_init(rdev, 64 * 1024);
5265
5266	r = r600_pcie_gart_init(rdev);
5267	if (r)
5268		return r;
5269
5270	rdev->accel_working = true;
5271	r = evergreen_startup(rdev);
5272	if (r) {
5273		dev_err(rdev->dev, "disabling GPU acceleration\n");
5274		r700_cp_fini(rdev);
5275		r600_dma_fini(rdev);
5276		r600_irq_fini(rdev);
5277		if (rdev->flags & RADEON_IS_IGP)
5278			sumo_rlc_fini(rdev);
5279		radeon_wb_fini(rdev);
5280		radeon_ib_pool_fini(rdev);
5281		radeon_irq_kms_fini(rdev);
5282		evergreen_pcie_gart_fini(rdev);
5283		rdev->accel_working = false;
5284	}
5285
5286	/* Don't start up if the MC ucode is missing on BTC parts.
5287	 * The default clocks and voltages before the MC ucode
5288	 * is loaded are not suffient for advanced operations.
5289	 */
5290	if (ASIC_IS_DCE5(rdev)) {
5291		if (!rdev->mc_fw && !(rdev->flags & RADEON_IS_IGP)) {
5292			DRM_ERROR("radeon: MC ucode required for NI+.\n");
5293			return -EINVAL;
5294		}
5295	}
5296
5297	return 0;
5298}
5299
5300void evergreen_fini(struct radeon_device *rdev)
5301{
5302	radeon_pm_fini(rdev);
5303	radeon_audio_fini(rdev);
5304	r700_cp_fini(rdev);
5305	r600_dma_fini(rdev);
5306	r600_irq_fini(rdev);
5307	if (rdev->flags & RADEON_IS_IGP)
5308		sumo_rlc_fini(rdev);
5309	radeon_wb_fini(rdev);
5310	radeon_ib_pool_fini(rdev);
5311	radeon_irq_kms_fini(rdev);
5312	uvd_v1_0_fini(rdev);
5313	radeon_uvd_fini(rdev);
5314	evergreen_pcie_gart_fini(rdev);
5315	r600_vram_scratch_fini(rdev);
5316	radeon_gem_fini(rdev);
5317	radeon_fence_driver_fini(rdev);
5318	radeon_agp_fini(rdev);
5319	radeon_bo_fini(rdev);
5320	radeon_atombios_fini(rdev);
5321	kfree(rdev->bios);
5322	rdev->bios = NULL;
5323}
5324
5325void evergreen_pcie_gen2_enable(struct radeon_device *rdev)
5326{
5327	u32 link_width_cntl, speed_cntl;
5328
5329	if (radeon_pcie_gen2 == 0)
5330		return;
5331
5332	if (rdev->flags & RADEON_IS_IGP)
5333		return;
5334
5335	if (!(rdev->flags & RADEON_IS_PCIE))
5336		return;
5337
5338	/* x2 cards have a special sequence */
5339	if (ASIC_IS_X2(rdev))
5340		return;
5341
5342	if ((rdev->pdev->bus->max_bus_speed != PCIE_SPEED_5_0GT) &&
5343		(rdev->pdev->bus->max_bus_speed != PCIE_SPEED_8_0GT))
5344		return;
5345
5346	speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
5347	if (speed_cntl & LC_CURRENT_DATA_RATE) {
5348		DRM_INFO("PCIE gen 2 link speeds already enabled\n");
5349		return;
5350	}
5351
5352	DRM_INFO("enabling PCIE gen 2 link speeds, disable with radeon.pcie_gen2=0\n");
5353
5354	if ((speed_cntl & LC_OTHER_SIDE_EVER_SENT_GEN2) ||
5355	    (speed_cntl & LC_OTHER_SIDE_SUPPORTS_GEN2)) {
5356
5357		link_width_cntl = RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL);
5358		link_width_cntl &= ~LC_UPCONFIGURE_DIS;
5359		WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl);
5360
5361		speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
5362		speed_cntl &= ~LC_TARGET_LINK_SPEED_OVERRIDE_EN;
5363		WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
5364
5365		speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
5366		speed_cntl |= LC_CLR_FAILED_SPD_CHANGE_CNT;
5367		WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
5368
5369		speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
5370		speed_cntl &= ~LC_CLR_FAILED_SPD_CHANGE_CNT;
5371		WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
5372
5373		speed_cntl = RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL);
5374		speed_cntl |= LC_GEN2_EN_STRAP;
5375		WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL, speed_cntl);
5376
5377	} else {
5378		link_width_cntl = RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL);
5379		/* XXX: only disable it if gen1 bridge vendor == 0x111d or 0x1106 */
5380		if (1)
5381			link_width_cntl |= LC_UPCONFIGURE_DIS;
5382		else
5383			link_width_cntl &= ~LC_UPCONFIGURE_DIS;
5384		WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL, link_width_cntl);
5385	}
5386}
5387
5388void evergreen_program_aspm(struct radeon_device *rdev)
5389{
5390	u32 data, orig;
5391	u32 pcie_lc_cntl, pcie_lc_cntl_old;
5392	bool disable_l0s, disable_l1 = false, disable_plloff_in_l1 = false;
5393	/* fusion_platform = true
5394	 * if the system is a fusion system
5395	 * (APU or DGPU in a fusion system).
5396	 * todo: check if the system is a fusion platform.
5397	 */
5398	bool fusion_platform = false;
5399
5400	if (radeon_aspm == 0)
5401		return;
5402
5403	if (!(rdev->flags & RADEON_IS_PCIE))
5404		return;
5405
5406	switch (rdev->family) {
5407	case CHIP_CYPRESS:
5408	case CHIP_HEMLOCK:
5409	case CHIP_JUNIPER:
5410	case CHIP_REDWOOD:
5411	case CHIP_CEDAR:
5412	case CHIP_SUMO:
5413	case CHIP_SUMO2:
5414	case CHIP_PALM:
5415	case CHIP_ARUBA:
5416		disable_l0s = true;
5417		break;
5418	default:
5419		disable_l0s = false;
5420		break;
5421	}
5422
5423	if (rdev->flags & RADEON_IS_IGP)
5424		fusion_platform = true; /* XXX also dGPUs in a fusion system */
5425
5426	data = orig = RREG32_PIF_PHY0(PB0_PIF_PAIRING);
5427	if (fusion_platform)
5428		data &= ~MULTI_PIF;
5429	else
5430		data |= MULTI_PIF;
5431	if (data != orig)
5432		WREG32_PIF_PHY0(PB0_PIF_PAIRING, data);
5433
5434	data = orig = RREG32_PIF_PHY1(PB1_PIF_PAIRING);
5435	if (fusion_platform)
5436		data &= ~MULTI_PIF;
5437	else
5438		data |= MULTI_PIF;
5439	if (data != orig)
5440		WREG32_PIF_PHY1(PB1_PIF_PAIRING, data);
5441
5442	pcie_lc_cntl = pcie_lc_cntl_old = RREG32_PCIE_PORT(PCIE_LC_CNTL);
5443	pcie_lc_cntl &= ~(LC_L0S_INACTIVITY_MASK | LC_L1_INACTIVITY_MASK);
5444	if (!disable_l0s) {
5445		if (rdev->family >= CHIP_BARTS)
5446			pcie_lc_cntl |= LC_L0S_INACTIVITY(7);
5447		else
5448			pcie_lc_cntl |= LC_L0S_INACTIVITY(3);
5449	}
5450
5451	if (!disable_l1) {
5452		if (rdev->family >= CHIP_BARTS)
5453			pcie_lc_cntl |= LC_L1_INACTIVITY(7);
5454		else
5455			pcie_lc_cntl |= LC_L1_INACTIVITY(8);
5456
5457		if (!disable_plloff_in_l1) {
5458			data = orig = RREG32_PIF_PHY0(PB0_PIF_PWRDOWN_0);
5459			data &= ~(PLL_POWER_STATE_IN_OFF_0_MASK | PLL_POWER_STATE_IN_TXS2_0_MASK);
5460			data |= PLL_POWER_STATE_IN_OFF_0(7) | PLL_POWER_STATE_IN_TXS2_0(7);
5461			if (data != orig)
5462				WREG32_PIF_PHY0(PB0_PIF_PWRDOWN_0, data);
5463
5464			data = orig = RREG32_PIF_PHY0(PB0_PIF_PWRDOWN_1);
5465			data &= ~(PLL_POWER_STATE_IN_OFF_1_MASK | PLL_POWER_STATE_IN_TXS2_1_MASK);
5466			data |= PLL_POWER_STATE_IN_OFF_1(7) | PLL_POWER_STATE_IN_TXS2_1(7);
5467			if (data != orig)
5468				WREG32_PIF_PHY0(PB0_PIF_PWRDOWN_1, data);
5469
5470			data = orig = RREG32_PIF_PHY1(PB1_PIF_PWRDOWN_0);
5471			data &= ~(PLL_POWER_STATE_IN_OFF_0_MASK | PLL_POWER_STATE_IN_TXS2_0_MASK);
5472			data |= PLL_POWER_STATE_IN_OFF_0(7) | PLL_POWER_STATE_IN_TXS2_0(7);
5473			if (data != orig)
5474				WREG32_PIF_PHY1(PB1_PIF_PWRDOWN_0, data);
5475
5476			data = orig = RREG32_PIF_PHY1(PB1_PIF_PWRDOWN_1);
5477			data &= ~(PLL_POWER_STATE_IN_OFF_1_MASK | PLL_POWER_STATE_IN_TXS2_1_MASK);
5478			data |= PLL_POWER_STATE_IN_OFF_1(7) | PLL_POWER_STATE_IN_TXS2_1(7);
5479			if (data != orig)
5480				WREG32_PIF_PHY1(PB1_PIF_PWRDOWN_1, data);
5481
5482			if (rdev->family >= CHIP_BARTS) {
5483				data = orig = RREG32_PIF_PHY0(PB0_PIF_PWRDOWN_0);
5484				data &= ~PLL_RAMP_UP_TIME_0_MASK;
5485				data |= PLL_RAMP_UP_TIME_0(4);
5486				if (data != orig)
5487					WREG32_PIF_PHY0(PB0_PIF_PWRDOWN_0, data);
5488
5489				data = orig = RREG32_PIF_PHY0(PB0_PIF_PWRDOWN_1);
5490				data &= ~PLL_RAMP_UP_TIME_1_MASK;
5491				data |= PLL_RAMP_UP_TIME_1(4);
5492				if (data != orig)
5493					WREG32_PIF_PHY0(PB0_PIF_PWRDOWN_1, data);
5494
5495				data = orig = RREG32_PIF_PHY1(PB1_PIF_PWRDOWN_0);
5496				data &= ~PLL_RAMP_UP_TIME_0_MASK;
5497				data |= PLL_RAMP_UP_TIME_0(4);
5498				if (data != orig)
5499					WREG32_PIF_PHY1(PB1_PIF_PWRDOWN_0, data);
5500
5501				data = orig = RREG32_PIF_PHY1(PB1_PIF_PWRDOWN_1);
5502				data &= ~PLL_RAMP_UP_TIME_1_MASK;
5503				data |= PLL_RAMP_UP_TIME_1(4);
5504				if (data != orig)
5505					WREG32_PIF_PHY1(PB1_PIF_PWRDOWN_1, data);
5506			}
5507
5508			data = orig = RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL);
5509			data &= ~LC_DYN_LANES_PWR_STATE_MASK;
5510			data |= LC_DYN_LANES_PWR_STATE(3);
5511			if (data != orig)
5512				WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL, data);
5513
5514			if (rdev->family >= CHIP_BARTS) {
5515				data = orig = RREG32_PIF_PHY0(PB0_PIF_CNTL);
5516				data &= ~LS2_EXIT_TIME_MASK;
5517				data |= LS2_EXIT_TIME(1);
5518				if (data != orig)
5519					WREG32_PIF_PHY0(PB0_PIF_CNTL, data);
5520
5521				data = orig = RREG32_PIF_PHY1(PB1_PIF_CNTL);
5522				data &= ~LS2_EXIT_TIME_MASK;
5523				data |= LS2_EXIT_TIME(1);
5524				if (data != orig)
5525					WREG32_PIF_PHY1(PB1_PIF_CNTL, data);
5526			}
5527		}
5528	}
5529
5530	/* evergreen parts only */
5531	if (rdev->family < CHIP_BARTS)
5532		pcie_lc_cntl |= LC_PMI_TO_L1_DIS;
5533
5534	if (pcie_lc_cntl != pcie_lc_cntl_old)
5535		WREG32_PCIE_PORT(PCIE_LC_CNTL, pcie_lc_cntl);
5536}