Subversion Repositories Kolibri OS

Rev

Rev 6661 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  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. #include <linux/firmware.h>
  25. #include <linux/slab.h>
  26. #include <drm/drmP.h>
  27. #include "radeon.h"
  28. #include "radeon_asic.h"
  29. #include "radeon_audio.h"
  30. #include <drm/radeon_drm.h>
  31. #include "evergreend.h"
  32. #include "atom.h"
  33. #include "avivod.h"
  34. #include "evergreen_reg.h"
  35. #include "evergreen_blit_shaders.h"
  36. #include "radeon_ucode.h"
  37.  
  38. /*
  39.  * Indirect registers accessor
  40.  */
  41. u32 eg_cg_rreg(struct radeon_device *rdev, u32 reg)
  42. {
  43.         unsigned long flags;
  44.         u32 r;
  45.  
  46.         spin_lock_irqsave(&rdev->cg_idx_lock, flags);
  47.         WREG32(EVERGREEN_CG_IND_ADDR, ((reg) & 0xffff));
  48.         r = RREG32(EVERGREEN_CG_IND_DATA);
  49.         spin_unlock_irqrestore(&rdev->cg_idx_lock, flags);
  50.         return r;
  51. }
  52.  
  53. void eg_cg_wreg(struct radeon_device *rdev, u32 reg, u32 v)
  54. {
  55.         unsigned long flags;
  56.  
  57.         spin_lock_irqsave(&rdev->cg_idx_lock, flags);
  58.         WREG32(EVERGREEN_CG_IND_ADDR, ((reg) & 0xffff));
  59.         WREG32(EVERGREEN_CG_IND_DATA, (v));
  60.         spin_unlock_irqrestore(&rdev->cg_idx_lock, flags);
  61. }
  62.  
  63. u32 eg_pif_phy0_rreg(struct radeon_device *rdev, u32 reg)
  64. {
  65.         unsigned long flags;
  66.         u32 r;
  67.  
  68.         spin_lock_irqsave(&rdev->pif_idx_lock, flags);
  69.         WREG32(EVERGREEN_PIF_PHY0_INDEX, ((reg) & 0xffff));
  70.         r = RREG32(EVERGREEN_PIF_PHY0_DATA);
  71.         spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
  72.         return r;
  73. }
  74.  
  75. void eg_pif_phy0_wreg(struct radeon_device *rdev, u32 reg, u32 v)
  76. {
  77.         unsigned long flags;
  78.  
  79.         spin_lock_irqsave(&rdev->pif_idx_lock, flags);
  80.         WREG32(EVERGREEN_PIF_PHY0_INDEX, ((reg) & 0xffff));
  81.         WREG32(EVERGREEN_PIF_PHY0_DATA, (v));
  82.         spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
  83. }
  84.  
  85. u32 eg_pif_phy1_rreg(struct radeon_device *rdev, u32 reg)
  86. {
  87.         unsigned long flags;
  88.         u32 r;
  89.  
  90.         spin_lock_irqsave(&rdev->pif_idx_lock, flags);
  91.         WREG32(EVERGREEN_PIF_PHY1_INDEX, ((reg) & 0xffff));
  92.         r = RREG32(EVERGREEN_PIF_PHY1_DATA);
  93.         spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
  94.         return r;
  95. }
  96.  
  97. void eg_pif_phy1_wreg(struct radeon_device *rdev, u32 reg, u32 v)
  98. {
  99.         unsigned long flags;
  100.  
  101.         spin_lock_irqsave(&rdev->pif_idx_lock, flags);
  102.         WREG32(EVERGREEN_PIF_PHY1_INDEX, ((reg) & 0xffff));
  103.         WREG32(EVERGREEN_PIF_PHY1_DATA, (v));
  104.         spin_unlock_irqrestore(&rdev->pif_idx_lock, flags);
  105. }
  106.  
  107. static const u32 crtc_offsets[6] =
  108. {
  109.         EVERGREEN_CRTC0_REGISTER_OFFSET,
  110.         EVERGREEN_CRTC1_REGISTER_OFFSET,
  111.         EVERGREEN_CRTC2_REGISTER_OFFSET,
  112.         EVERGREEN_CRTC3_REGISTER_OFFSET,
  113.         EVERGREEN_CRTC4_REGISTER_OFFSET,
  114.         EVERGREEN_CRTC5_REGISTER_OFFSET
  115. };
  116.  
  117. #include "clearstate_evergreen.h"
  118.  
  119. static const u32 sumo_rlc_save_restore_register_list[] =
  120. {
  121.         0x98fc,
  122.         0x9830,
  123.         0x9834,
  124.         0x9838,
  125.         0x9870,
  126.         0x9874,
  127.         0x8a14,
  128.         0x8b24,
  129.         0x8bcc,
  130.         0x8b10,
  131.         0x8d00,
  132.         0x8d04,
  133.         0x8c00,
  134.         0x8c04,
  135.         0x8c08,
  136.         0x8c0c,
  137.         0x8d8c,
  138.         0x8c20,
  139.         0x8c24,
  140.         0x8c28,
  141.         0x8c18,
  142.         0x8c1c,
  143.         0x8cf0,
  144.         0x8e2c,
  145.         0x8e38,
  146.         0x8c30,
  147.         0x9508,
  148.         0x9688,
  149.         0x9608,
  150.         0x960c,
  151.         0x9610,
  152.         0x9614,
  153.         0x88c4,
  154.         0x88d4,
  155.         0xa008,
  156.         0x900c,
  157.         0x9100,
  158.         0x913c,
  159.         0x98f8,
  160.         0x98f4,
  161.         0x9b7c,
  162.         0x3f8c,
  163.         0x8950,
  164.         0x8954,
  165.         0x8a18,
  166.         0x8b28,
  167.         0x9144,
  168.         0x9148,
  169.         0x914c,
  170.         0x3f90,
  171.         0x3f94,
  172.         0x915c,
  173.         0x9160,
  174.         0x9178,
  175.         0x917c,
  176.         0x9180,
  177.         0x918c,
  178.         0x9190,
  179.         0x9194,
  180.         0x9198,
  181.         0x919c,
  182.         0x91a8,
  183.         0x91ac,
  184.         0x91b0,
  185.         0x91b4,
  186.         0x91b8,
  187.         0x91c4,
  188.         0x91c8,
  189.         0x91cc,
  190.         0x91d0,
  191.         0x91d4,
  192.         0x91e0,
  193.         0x91e4,
  194.         0x91ec,
  195.         0x91f0,
  196.         0x91f4,
  197.         0x9200,
  198.         0x9204,
  199.         0x929c,
  200.         0x9150,
  201.         0x802c,
  202. };
  203.  
  204. static void evergreen_gpu_init(struct radeon_device *rdev);
  205. void evergreen_fini(struct radeon_device *rdev);
  206. void evergreen_pcie_gen2_enable(struct radeon_device *rdev);
  207. void evergreen_program_aspm(struct radeon_device *rdev);
  208. extern void cayman_cp_int_cntl_setup(struct radeon_device *rdev,
  209.                                      int ring, u32 cp_int_cntl);
  210. extern void cayman_vm_decode_fault(struct radeon_device *rdev,
  211.                                    u32 status, u32 addr);
  212. void cik_init_cp_pg_table(struct radeon_device *rdev);
  213.  
  214. extern u32 si_get_csb_size(struct radeon_device *rdev);
  215. extern void si_get_csb_buffer(struct radeon_device *rdev, volatile u32 *buffer);
  216. extern u32 cik_get_csb_size(struct radeon_device *rdev);
  217. extern void cik_get_csb_buffer(struct radeon_device *rdev, volatile u32 *buffer);
  218. extern void rv770_set_clk_bypass_mode(struct radeon_device *rdev);
  219.  
  220. static const u32 evergreen_golden_registers[] =
  221. {
  222.         0x3f90, 0xffff0000, 0xff000000,
  223.         0x9148, 0xffff0000, 0xff000000,
  224.         0x3f94, 0xffff0000, 0xff000000,
  225.         0x914c, 0xffff0000, 0xff000000,
  226.         0x9b7c, 0xffffffff, 0x00000000,
  227.         0x8a14, 0xffffffff, 0x00000007,
  228.         0x8b10, 0xffffffff, 0x00000000,
  229.         0x960c, 0xffffffff, 0x54763210,
  230.         0x88c4, 0xffffffff, 0x000000c2,
  231.         0x88d4, 0xffffffff, 0x00000010,
  232.         0x8974, 0xffffffff, 0x00000000,
  233.         0xc78, 0x00000080, 0x00000080,
  234.         0x5eb4, 0xffffffff, 0x00000002,
  235.         0x5e78, 0xffffffff, 0x001000f0,
  236.         0x6104, 0x01000300, 0x00000000,
  237.         0x5bc0, 0x00300000, 0x00000000,
  238.         0x7030, 0xffffffff, 0x00000011,
  239.         0x7c30, 0xffffffff, 0x00000011,
  240.         0x10830, 0xffffffff, 0x00000011,
  241.         0x11430, 0xffffffff, 0x00000011,
  242.         0x12030, 0xffffffff, 0x00000011,
  243.         0x12c30, 0xffffffff, 0x00000011,
  244.         0xd02c, 0xffffffff, 0x08421000,
  245.         0x240c, 0xffffffff, 0x00000380,
  246.         0x8b24, 0xffffffff, 0x00ff0fff,
  247.         0x28a4c, 0x06000000, 0x06000000,
  248.         0x10c, 0x00000001, 0x00000001,
  249.         0x8d00, 0xffffffff, 0x100e4848,
  250.         0x8d04, 0xffffffff, 0x00164745,
  251.         0x8c00, 0xffffffff, 0xe4000003,
  252.         0x8c04, 0xffffffff, 0x40600060,
  253.         0x8c08, 0xffffffff, 0x001c001c,
  254.         0x8cf0, 0xffffffff, 0x08e00620,
  255.         0x8c20, 0xffffffff, 0x00800080,
  256.         0x8c24, 0xffffffff, 0x00800080,
  257.         0x8c18, 0xffffffff, 0x20202078,
  258.         0x8c1c, 0xffffffff, 0x00001010,
  259.         0x28350, 0xffffffff, 0x00000000,
  260.         0xa008, 0xffffffff, 0x00010000,
  261.         0x5c4, 0xffffffff, 0x00000001,
  262.         0x9508, 0xffffffff, 0x00000002,
  263.         0x913c, 0x0000000f, 0x0000000a
  264. };
  265.  
  266. static const u32 evergreen_golden_registers2[] =
  267. {
  268.         0x2f4c, 0xffffffff, 0x00000000,
  269.         0x54f4, 0xffffffff, 0x00000000,
  270.         0x54f0, 0xffffffff, 0x00000000,
  271.         0x5498, 0xffffffff, 0x00000000,
  272.         0x549c, 0xffffffff, 0x00000000,
  273.         0x5494, 0xffffffff, 0x00000000,
  274.         0x53cc, 0xffffffff, 0x00000000,
  275.         0x53c8, 0xffffffff, 0x00000000,
  276.         0x53c4, 0xffffffff, 0x00000000,
  277.         0x53c0, 0xffffffff, 0x00000000,
  278.         0x53bc, 0xffffffff, 0x00000000,
  279.         0x53b8, 0xffffffff, 0x00000000,
  280.         0x53b4, 0xffffffff, 0x00000000,
  281.         0x53b0, 0xffffffff, 0x00000000
  282. };
  283.  
  284. static const u32 cypress_mgcg_init[] =
  285. {
  286.         0x802c, 0xffffffff, 0xc0000000,
  287.         0x5448, 0xffffffff, 0x00000100,
  288.         0x55e4, 0xffffffff, 0x00000100,
  289.         0x160c, 0xffffffff, 0x00000100,
  290.         0x5644, 0xffffffff, 0x00000100,
  291.         0xc164, 0xffffffff, 0x00000100,
  292.         0x8a18, 0xffffffff, 0x00000100,
  293.         0x897c, 0xffffffff, 0x06000100,
  294.         0x8b28, 0xffffffff, 0x00000100,
  295.         0x9144, 0xffffffff, 0x00000100,
  296.         0x9a60, 0xffffffff, 0x00000100,
  297.         0x9868, 0xffffffff, 0x00000100,
  298.         0x8d58, 0xffffffff, 0x00000100,
  299.         0x9510, 0xffffffff, 0x00000100,
  300.         0x949c, 0xffffffff, 0x00000100,
  301.         0x9654, 0xffffffff, 0x00000100,
  302.         0x9030, 0xffffffff, 0x00000100,
  303.         0x9034, 0xffffffff, 0x00000100,
  304.         0x9038, 0xffffffff, 0x00000100,
  305.         0x903c, 0xffffffff, 0x00000100,
  306.         0x9040, 0xffffffff, 0x00000100,
  307.         0xa200, 0xffffffff, 0x00000100,
  308.         0xa204, 0xffffffff, 0x00000100,
  309.         0xa208, 0xffffffff, 0x00000100,
  310.         0xa20c, 0xffffffff, 0x00000100,
  311.         0x971c, 0xffffffff, 0x00000100,
  312.         0x977c, 0xffffffff, 0x00000100,
  313.         0x3f80, 0xffffffff, 0x00000100,
  314.         0xa210, 0xffffffff, 0x00000100,
  315.         0xa214, 0xffffffff, 0x00000100,
  316.         0x4d8, 0xffffffff, 0x00000100,
  317.         0x9784, 0xffffffff, 0x00000100,
  318.         0x9698, 0xffffffff, 0x00000100,
  319.         0x4d4, 0xffffffff, 0x00000200,
  320.         0x30cc, 0xffffffff, 0x00000100,
  321.         0xd0c0, 0xffffffff, 0xff000100,
  322.         0x802c, 0xffffffff, 0x40000000,
  323.         0x915c, 0xffffffff, 0x00010000,
  324.         0x9160, 0xffffffff, 0x00030002,
  325.         0x9178, 0xffffffff, 0x00070000,
  326.         0x917c, 0xffffffff, 0x00030002,
  327.         0x9180, 0xffffffff, 0x00050004,
  328.         0x918c, 0xffffffff, 0x00010006,
  329.         0x9190, 0xffffffff, 0x00090008,
  330.         0x9194, 0xffffffff, 0x00070000,
  331.         0x9198, 0xffffffff, 0x00030002,
  332.         0x919c, 0xffffffff, 0x00050004,
  333.         0x91a8, 0xffffffff, 0x00010006,
  334.         0x91ac, 0xffffffff, 0x00090008,
  335.         0x91b0, 0xffffffff, 0x00070000,
  336.         0x91b4, 0xffffffff, 0x00030002,
  337.         0x91b8, 0xffffffff, 0x00050004,
  338.         0x91c4, 0xffffffff, 0x00010006,
  339.         0x91c8, 0xffffffff, 0x00090008,
  340.         0x91cc, 0xffffffff, 0x00070000,
  341.         0x91d0, 0xffffffff, 0x00030002,
  342.         0x91d4, 0xffffffff, 0x00050004,
  343.         0x91e0, 0xffffffff, 0x00010006,
  344.         0x91e4, 0xffffffff, 0x00090008,
  345.         0x91e8, 0xffffffff, 0x00000000,
  346.         0x91ec, 0xffffffff, 0x00070000,
  347.         0x91f0, 0xffffffff, 0x00030002,
  348.         0x91f4, 0xffffffff, 0x00050004,
  349.         0x9200, 0xffffffff, 0x00010006,
  350.         0x9204, 0xffffffff, 0x00090008,
  351.         0x9208, 0xffffffff, 0x00070000,
  352.         0x920c, 0xffffffff, 0x00030002,
  353.         0x9210, 0xffffffff, 0x00050004,
  354.         0x921c, 0xffffffff, 0x00010006,
  355.         0x9220, 0xffffffff, 0x00090008,
  356.         0x9224, 0xffffffff, 0x00070000,
  357.         0x9228, 0xffffffff, 0x00030002,
  358.         0x922c, 0xffffffff, 0x00050004,
  359.         0x9238, 0xffffffff, 0x00010006,
  360.         0x923c, 0xffffffff, 0x00090008,
  361.         0x9240, 0xffffffff, 0x00070000,
  362.         0x9244, 0xffffffff, 0x00030002,
  363.         0x9248, 0xffffffff, 0x00050004,
  364.         0x9254, 0xffffffff, 0x00010006,
  365.         0x9258, 0xffffffff, 0x00090008,
  366.         0x925c, 0xffffffff, 0x00070000,
  367.         0x9260, 0xffffffff, 0x00030002,
  368.         0x9264, 0xffffffff, 0x00050004,
  369.         0x9270, 0xffffffff, 0x00010006,
  370.         0x9274, 0xffffffff, 0x00090008,
  371.         0x9278, 0xffffffff, 0x00070000,
  372.         0x927c, 0xffffffff, 0x00030002,
  373.         0x9280, 0xffffffff, 0x00050004,
  374.         0x928c, 0xffffffff, 0x00010006,
  375.         0x9290, 0xffffffff, 0x00090008,
  376.         0x9294, 0xffffffff, 0x00000000,
  377.         0x929c, 0xffffffff, 0x00000001,
  378.         0x802c, 0xffffffff, 0x40010000,
  379.         0x915c, 0xffffffff, 0x00010000,
  380.         0x9160, 0xffffffff, 0x00030002,
  381.         0x9178, 0xffffffff, 0x00070000,
  382.         0x917c, 0xffffffff, 0x00030002,
  383.         0x9180, 0xffffffff, 0x00050004,
  384.         0x918c, 0xffffffff, 0x00010006,
  385.         0x9190, 0xffffffff, 0x00090008,
  386.         0x9194, 0xffffffff, 0x00070000,
  387.         0x9198, 0xffffffff, 0x00030002,
  388.         0x919c, 0xffffffff, 0x00050004,
  389.         0x91a8, 0xffffffff, 0x00010006,
  390.         0x91ac, 0xffffffff, 0x00090008,
  391.         0x91b0, 0xffffffff, 0x00070000,
  392.         0x91b4, 0xffffffff, 0x00030002,
  393.         0x91b8, 0xffffffff, 0x00050004,
  394.         0x91c4, 0xffffffff, 0x00010006,
  395.         0x91c8, 0xffffffff, 0x00090008,
  396.         0x91cc, 0xffffffff, 0x00070000,
  397.         0x91d0, 0xffffffff, 0x00030002,
  398.         0x91d4, 0xffffffff, 0x00050004,
  399.         0x91e0, 0xffffffff, 0x00010006,
  400.         0x91e4, 0xffffffff, 0x00090008,
  401.         0x91e8, 0xffffffff, 0x00000000,
  402.         0x91ec, 0xffffffff, 0x00070000,
  403.         0x91f0, 0xffffffff, 0x00030002,
  404.         0x91f4, 0xffffffff, 0x00050004,
  405.         0x9200, 0xffffffff, 0x00010006,
  406.         0x9204, 0xffffffff, 0x00090008,
  407.         0x9208, 0xffffffff, 0x00070000,
  408.         0x920c, 0xffffffff, 0x00030002,
  409.         0x9210, 0xffffffff, 0x00050004,
  410.         0x921c, 0xffffffff, 0x00010006,
  411.         0x9220, 0xffffffff, 0x00090008,
  412.         0x9224, 0xffffffff, 0x00070000,
  413.         0x9228, 0xffffffff, 0x00030002,
  414.         0x922c, 0xffffffff, 0x00050004,
  415.         0x9238, 0xffffffff, 0x00010006,
  416.         0x923c, 0xffffffff, 0x00090008,
  417.         0x9240, 0xffffffff, 0x00070000,
  418.         0x9244, 0xffffffff, 0x00030002,
  419.         0x9248, 0xffffffff, 0x00050004,
  420.         0x9254, 0xffffffff, 0x00010006,
  421.         0x9258, 0xffffffff, 0x00090008,
  422.         0x925c, 0xffffffff, 0x00070000,
  423.         0x9260, 0xffffffff, 0x00030002,
  424.         0x9264, 0xffffffff, 0x00050004,
  425.         0x9270, 0xffffffff, 0x00010006,
  426.         0x9274, 0xffffffff, 0x00090008,
  427.         0x9278, 0xffffffff, 0x00070000,
  428.         0x927c, 0xffffffff, 0x00030002,
  429.         0x9280, 0xffffffff, 0x00050004,
  430.         0x928c, 0xffffffff, 0x00010006,
  431.         0x9290, 0xffffffff, 0x00090008,
  432.         0x9294, 0xffffffff, 0x00000000,
  433.         0x929c, 0xffffffff, 0x00000001,
  434.         0x802c, 0xffffffff, 0xc0000000
  435. };
  436.  
  437. static const u32 redwood_mgcg_init[] =
  438. {
  439.         0x802c, 0xffffffff, 0xc0000000,
  440.         0x5448, 0xffffffff, 0x00000100,
  441.         0x55e4, 0xffffffff, 0x00000100,
  442.         0x160c, 0xffffffff, 0x00000100,
  443.         0x5644, 0xffffffff, 0x00000100,
  444.         0xc164, 0xffffffff, 0x00000100,
  445.         0x8a18, 0xffffffff, 0x00000100,
  446.         0x897c, 0xffffffff, 0x06000100,
  447.         0x8b28, 0xffffffff, 0x00000100,
  448.         0x9144, 0xffffffff, 0x00000100,
  449.         0x9a60, 0xffffffff, 0x00000100,
  450.         0x9868, 0xffffffff, 0x00000100,
  451.         0x8d58, 0xffffffff, 0x00000100,
  452.         0x9510, 0xffffffff, 0x00000100,
  453.         0x949c, 0xffffffff, 0x00000100,
  454.         0x9654, 0xffffffff, 0x00000100,
  455.         0x9030, 0xffffffff, 0x00000100,
  456.         0x9034, 0xffffffff, 0x00000100,
  457.         0x9038, 0xffffffff, 0x00000100,
  458.         0x903c, 0xffffffff, 0x00000100,
  459.         0x9040, 0xffffffff, 0x00000100,
  460.         0xa200, 0xffffffff, 0x00000100,
  461.         0xa204, 0xffffffff, 0x00000100,
  462.         0xa208, 0xffffffff, 0x00000100,
  463.         0xa20c, 0xffffffff, 0x00000100,
  464.         0x971c, 0xffffffff, 0x00000100,
  465.         0x977c, 0xffffffff, 0x00000100,
  466.         0x3f80, 0xffffffff, 0x00000100,
  467.         0xa210, 0xffffffff, 0x00000100,
  468.         0xa214, 0xffffffff, 0x00000100,
  469.         0x4d8, 0xffffffff, 0x00000100,
  470.         0x9784, 0xffffffff, 0x00000100,
  471.         0x9698, 0xffffffff, 0x00000100,
  472.         0x4d4, 0xffffffff, 0x00000200,
  473.         0x30cc, 0xffffffff, 0x00000100,
  474.         0xd0c0, 0xffffffff, 0xff000100,
  475.         0x802c, 0xffffffff, 0x40000000,
  476.         0x915c, 0xffffffff, 0x00010000,
  477.         0x9160, 0xffffffff, 0x00030002,
  478.         0x9178, 0xffffffff, 0x00070000,
  479.         0x917c, 0xffffffff, 0x00030002,
  480.         0x9180, 0xffffffff, 0x00050004,
  481.         0x918c, 0xffffffff, 0x00010006,
  482.         0x9190, 0xffffffff, 0x00090008,
  483.         0x9194, 0xffffffff, 0x00070000,
  484.         0x9198, 0xffffffff, 0x00030002,
  485.         0x919c, 0xffffffff, 0x00050004,
  486.         0x91a8, 0xffffffff, 0x00010006,
  487.         0x91ac, 0xffffffff, 0x00090008,
  488.         0x91b0, 0xffffffff, 0x00070000,
  489.         0x91b4, 0xffffffff, 0x00030002,
  490.         0x91b8, 0xffffffff, 0x00050004,
  491.         0x91c4, 0xffffffff, 0x00010006,
  492.         0x91c8, 0xffffffff, 0x00090008,
  493.         0x91cc, 0xffffffff, 0x00070000,
  494.         0x91d0, 0xffffffff, 0x00030002,
  495.         0x91d4, 0xffffffff, 0x00050004,
  496.         0x91e0, 0xffffffff, 0x00010006,
  497.         0x91e4, 0xffffffff, 0x00090008,
  498.         0x91e8, 0xffffffff, 0x00000000,
  499.         0x91ec, 0xffffffff, 0x00070000,
  500.         0x91f0, 0xffffffff, 0x00030002,
  501.         0x91f4, 0xffffffff, 0x00050004,
  502.         0x9200, 0xffffffff, 0x00010006,
  503.         0x9204, 0xffffffff, 0x00090008,
  504.         0x9294, 0xffffffff, 0x00000000,
  505.         0x929c, 0xffffffff, 0x00000001,
  506.         0x802c, 0xffffffff, 0xc0000000
  507. };
  508.  
  509. static const u32 cedar_golden_registers[] =
  510. {
  511.         0x3f90, 0xffff0000, 0xff000000,
  512.         0x9148, 0xffff0000, 0xff000000,
  513.         0x3f94, 0xffff0000, 0xff000000,
  514.         0x914c, 0xffff0000, 0xff000000,
  515.         0x9b7c, 0xffffffff, 0x00000000,
  516.         0x8a14, 0xffffffff, 0x00000007,
  517.         0x8b10, 0xffffffff, 0x00000000,
  518.         0x960c, 0xffffffff, 0x54763210,
  519.         0x88c4, 0xffffffff, 0x000000c2,
  520.         0x88d4, 0xffffffff, 0x00000000,
  521.         0x8974, 0xffffffff, 0x00000000,
  522.         0xc78, 0x00000080, 0x00000080,
  523.         0x5eb4, 0xffffffff, 0x00000002,
  524.         0x5e78, 0xffffffff, 0x001000f0,
  525.         0x6104, 0x01000300, 0x00000000,
  526.         0x5bc0, 0x00300000, 0x00000000,
  527.         0x7030, 0xffffffff, 0x00000011,
  528.         0x7c30, 0xffffffff, 0x00000011,
  529.         0x10830, 0xffffffff, 0x00000011,
  530.         0x11430, 0xffffffff, 0x00000011,
  531.         0xd02c, 0xffffffff, 0x08421000,
  532.         0x240c, 0xffffffff, 0x00000380,
  533.         0x8b24, 0xffffffff, 0x00ff0fff,
  534.         0x28a4c, 0x06000000, 0x06000000,
  535.         0x10c, 0x00000001, 0x00000001,
  536.         0x8d00, 0xffffffff, 0x100e4848,
  537.         0x8d04, 0xffffffff, 0x00164745,
  538.         0x8c00, 0xffffffff, 0xe4000003,
  539.         0x8c04, 0xffffffff, 0x40600060,
  540.         0x8c08, 0xffffffff, 0x001c001c,
  541.         0x8cf0, 0xffffffff, 0x08e00410,
  542.         0x8c20, 0xffffffff, 0x00800080,
  543.         0x8c24, 0xffffffff, 0x00800080,
  544.         0x8c18, 0xffffffff, 0x20202078,
  545.         0x8c1c, 0xffffffff, 0x00001010,
  546.         0x28350, 0xffffffff, 0x00000000,
  547.         0xa008, 0xffffffff, 0x00010000,
  548.         0x5c4, 0xffffffff, 0x00000001,
  549.         0x9508, 0xffffffff, 0x00000002
  550. };
  551.  
  552. static const u32 cedar_mgcg_init[] =
  553. {
  554.         0x802c, 0xffffffff, 0xc0000000,
  555.         0x5448, 0xffffffff, 0x00000100,
  556.         0x55e4, 0xffffffff, 0x00000100,
  557.         0x160c, 0xffffffff, 0x00000100,
  558.         0x5644, 0xffffffff, 0x00000100,
  559.         0xc164, 0xffffffff, 0x00000100,
  560.         0x8a18, 0xffffffff, 0x00000100,
  561.         0x897c, 0xffffffff, 0x06000100,
  562.         0x8b28, 0xffffffff, 0x00000100,
  563.         0x9144, 0xffffffff, 0x00000100,
  564.         0x9a60, 0xffffffff, 0x00000100,
  565.         0x9868, 0xffffffff, 0x00000100,
  566.         0x8d58, 0xffffffff, 0x00000100,
  567.         0x9510, 0xffffffff, 0x00000100,
  568.         0x949c, 0xffffffff, 0x00000100,
  569.         0x9654, 0xffffffff, 0x00000100,
  570.         0x9030, 0xffffffff, 0x00000100,
  571.         0x9034, 0xffffffff, 0x00000100,
  572.         0x9038, 0xffffffff, 0x00000100,
  573.         0x903c, 0xffffffff, 0x00000100,
  574.         0x9040, 0xffffffff, 0x00000100,
  575.         0xa200, 0xffffffff, 0x00000100,
  576.         0xa204, 0xffffffff, 0x00000100,
  577.         0xa208, 0xffffffff, 0x00000100,
  578.         0xa20c, 0xffffffff, 0x00000100,
  579.         0x971c, 0xffffffff, 0x00000100,
  580.         0x977c, 0xffffffff, 0x00000100,
  581.         0x3f80, 0xffffffff, 0x00000100,
  582.         0xa210, 0xffffffff, 0x00000100,
  583.         0xa214, 0xffffffff, 0x00000100,
  584.         0x4d8, 0xffffffff, 0x00000100,
  585.         0x9784, 0xffffffff, 0x00000100,
  586.         0x9698, 0xffffffff, 0x00000100,
  587.         0x4d4, 0xffffffff, 0x00000200,
  588.         0x30cc, 0xffffffff, 0x00000100,
  589.         0xd0c0, 0xffffffff, 0xff000100,
  590.         0x802c, 0xffffffff, 0x40000000,
  591.         0x915c, 0xffffffff, 0x00010000,
  592.         0x9178, 0xffffffff, 0x00050000,
  593.         0x917c, 0xffffffff, 0x00030002,
  594.         0x918c, 0xffffffff, 0x00010004,
  595.         0x9190, 0xffffffff, 0x00070006,
  596.         0x9194, 0xffffffff, 0x00050000,
  597.         0x9198, 0xffffffff, 0x00030002,
  598.         0x91a8, 0xffffffff, 0x00010004,
  599.         0x91ac, 0xffffffff, 0x00070006,
  600.         0x91e8, 0xffffffff, 0x00000000,
  601.         0x9294, 0xffffffff, 0x00000000,
  602.         0x929c, 0xffffffff, 0x00000001,
  603.         0x802c, 0xffffffff, 0xc0000000
  604. };
  605.  
  606. static const u32 juniper_mgcg_init[] =
  607. {
  608.         0x802c, 0xffffffff, 0xc0000000,
  609.         0x5448, 0xffffffff, 0x00000100,
  610.         0x55e4, 0xffffffff, 0x00000100,
  611.         0x160c, 0xffffffff, 0x00000100,
  612.         0x5644, 0xffffffff, 0x00000100,
  613.         0xc164, 0xffffffff, 0x00000100,
  614.         0x8a18, 0xffffffff, 0x00000100,
  615.         0x897c, 0xffffffff, 0x06000100,
  616.         0x8b28, 0xffffffff, 0x00000100,
  617.         0x9144, 0xffffffff, 0x00000100,
  618.         0x9a60, 0xffffffff, 0x00000100,
  619.         0x9868, 0xffffffff, 0x00000100,
  620.         0x8d58, 0xffffffff, 0x00000100,
  621.         0x9510, 0xffffffff, 0x00000100,
  622.         0x949c, 0xffffffff, 0x00000100,
  623.         0x9654, 0xffffffff, 0x00000100,
  624.         0x9030, 0xffffffff, 0x00000100,
  625.         0x9034, 0xffffffff, 0x00000100,
  626.         0x9038, 0xffffffff, 0x00000100,
  627.         0x903c, 0xffffffff, 0x00000100,
  628.         0x9040, 0xffffffff, 0x00000100,
  629.         0xa200, 0xffffffff, 0x00000100,
  630.         0xa204, 0xffffffff, 0x00000100,
  631.         0xa208, 0xffffffff, 0x00000100,
  632.         0xa20c, 0xffffffff, 0x00000100,
  633.         0x971c, 0xffffffff, 0x00000100,
  634.         0xd0c0, 0xffffffff, 0xff000100,
  635.         0x802c, 0xffffffff, 0x40000000,
  636.         0x915c, 0xffffffff, 0x00010000,
  637.         0x9160, 0xffffffff, 0x00030002,
  638.         0x9178, 0xffffffff, 0x00070000,
  639.         0x917c, 0xffffffff, 0x00030002,
  640.         0x9180, 0xffffffff, 0x00050004,
  641.         0x918c, 0xffffffff, 0x00010006,
  642.         0x9190, 0xffffffff, 0x00090008,
  643.         0x9194, 0xffffffff, 0x00070000,
  644.         0x9198, 0xffffffff, 0x00030002,
  645.         0x919c, 0xffffffff, 0x00050004,
  646.         0x91a8, 0xffffffff, 0x00010006,
  647.         0x91ac, 0xffffffff, 0x00090008,
  648.         0x91b0, 0xffffffff, 0x00070000,
  649.         0x91b4, 0xffffffff, 0x00030002,
  650.         0x91b8, 0xffffffff, 0x00050004,
  651.         0x91c4, 0xffffffff, 0x00010006,
  652.         0x91c8, 0xffffffff, 0x00090008,
  653.         0x91cc, 0xffffffff, 0x00070000,
  654.         0x91d0, 0xffffffff, 0x00030002,
  655.         0x91d4, 0xffffffff, 0x00050004,
  656.         0x91e0, 0xffffffff, 0x00010006,
  657.         0x91e4, 0xffffffff, 0x00090008,
  658.         0x91e8, 0xffffffff, 0x00000000,
  659.         0x91ec, 0xffffffff, 0x00070000,
  660.         0x91f0, 0xffffffff, 0x00030002,
  661.         0x91f4, 0xffffffff, 0x00050004,
  662.         0x9200, 0xffffffff, 0x00010006,
  663.         0x9204, 0xffffffff, 0x00090008,
  664.         0x9208, 0xffffffff, 0x00070000,
  665.         0x920c, 0xffffffff, 0x00030002,
  666.         0x9210, 0xffffffff, 0x00050004,
  667.         0x921c, 0xffffffff, 0x00010006,
  668.         0x9220, 0xffffffff, 0x00090008,
  669.         0x9224, 0xffffffff, 0x00070000,
  670.         0x9228, 0xffffffff, 0x00030002,
  671.         0x922c, 0xffffffff, 0x00050004,
  672.         0x9238, 0xffffffff, 0x00010006,
  673.         0x923c, 0xffffffff, 0x00090008,
  674.         0x9240, 0xffffffff, 0x00070000,
  675.         0x9244, 0xffffffff, 0x00030002,
  676.         0x9248, 0xffffffff, 0x00050004,
  677.         0x9254, 0xffffffff, 0x00010006,
  678.         0x9258, 0xffffffff, 0x00090008,
  679.         0x925c, 0xffffffff, 0x00070000,
  680.         0x9260, 0xffffffff, 0x00030002,
  681.         0x9264, 0xffffffff, 0x00050004,
  682.         0x9270, 0xffffffff, 0x00010006,
  683.         0x9274, 0xffffffff, 0x00090008,
  684.         0x9278, 0xffffffff, 0x00070000,
  685.         0x927c, 0xffffffff, 0x00030002,
  686.         0x9280, 0xffffffff, 0x00050004,
  687.         0x928c, 0xffffffff, 0x00010006,
  688.         0x9290, 0xffffffff, 0x00090008,
  689.         0x9294, 0xffffffff, 0x00000000,
  690.         0x929c, 0xffffffff, 0x00000001,
  691.         0x802c, 0xffffffff, 0xc0000000,
  692.         0x977c, 0xffffffff, 0x00000100,
  693.         0x3f80, 0xffffffff, 0x00000100,
  694.         0xa210, 0xffffffff, 0x00000100,
  695.         0xa214, 0xffffffff, 0x00000100,
  696.         0x4d8, 0xffffffff, 0x00000100,
  697.         0x9784, 0xffffffff, 0x00000100,
  698.         0x9698, 0xffffffff, 0x00000100,
  699.         0x4d4, 0xffffffff, 0x00000200,
  700.         0x30cc, 0xffffffff, 0x00000100,
  701.         0x802c, 0xffffffff, 0xc0000000
  702. };
  703.  
  704. static const u32 supersumo_golden_registers[] =
  705. {
  706.         0x5eb4, 0xffffffff, 0x00000002,
  707.         0x5c4, 0xffffffff, 0x00000001,
  708.         0x7030, 0xffffffff, 0x00000011,
  709.         0x7c30, 0xffffffff, 0x00000011,
  710.         0x6104, 0x01000300, 0x00000000,
  711.         0x5bc0, 0x00300000, 0x00000000,
  712.         0x8c04, 0xffffffff, 0x40600060,
  713.         0x8c08, 0xffffffff, 0x001c001c,
  714.         0x8c20, 0xffffffff, 0x00800080,
  715.         0x8c24, 0xffffffff, 0x00800080,
  716.         0x8c18, 0xffffffff, 0x20202078,
  717.         0x8c1c, 0xffffffff, 0x00001010,
  718.         0x918c, 0xffffffff, 0x00010006,
  719.         0x91a8, 0xffffffff, 0x00010006,
  720.         0x91c4, 0xffffffff, 0x00010006,
  721.         0x91e0, 0xffffffff, 0x00010006,
  722.         0x9200, 0xffffffff, 0x00010006,
  723.         0x9150, 0xffffffff, 0x6e944040,
  724.         0x917c, 0xffffffff, 0x00030002,
  725.         0x9180, 0xffffffff, 0x00050004,
  726.         0x9198, 0xffffffff, 0x00030002,
  727.         0x919c, 0xffffffff, 0x00050004,
  728.         0x91b4, 0xffffffff, 0x00030002,
  729.         0x91b8, 0xffffffff, 0x00050004,
  730.         0x91d0, 0xffffffff, 0x00030002,
  731.         0x91d4, 0xffffffff, 0x00050004,
  732.         0x91f0, 0xffffffff, 0x00030002,
  733.         0x91f4, 0xffffffff, 0x00050004,
  734.         0x915c, 0xffffffff, 0x00010000,
  735.         0x9160, 0xffffffff, 0x00030002,
  736.         0x3f90, 0xffff0000, 0xff000000,
  737.         0x9178, 0xffffffff, 0x00070000,
  738.         0x9194, 0xffffffff, 0x00070000,
  739.         0x91b0, 0xffffffff, 0x00070000,
  740.         0x91cc, 0xffffffff, 0x00070000,
  741.         0x91ec, 0xffffffff, 0x00070000,
  742.         0x9148, 0xffff0000, 0xff000000,
  743.         0x9190, 0xffffffff, 0x00090008,
  744.         0x91ac, 0xffffffff, 0x00090008,
  745.         0x91c8, 0xffffffff, 0x00090008,
  746.         0x91e4, 0xffffffff, 0x00090008,
  747.         0x9204, 0xffffffff, 0x00090008,
  748.         0x3f94, 0xffff0000, 0xff000000,
  749.         0x914c, 0xffff0000, 0xff000000,
  750.         0x929c, 0xffffffff, 0x00000001,
  751.         0x8a18, 0xffffffff, 0x00000100,
  752.         0x8b28, 0xffffffff, 0x00000100,
  753.         0x9144, 0xffffffff, 0x00000100,
  754.         0x5644, 0xffffffff, 0x00000100,
  755.         0x9b7c, 0xffffffff, 0x00000000,
  756.         0x8030, 0xffffffff, 0x0000100a,
  757.         0x8a14, 0xffffffff, 0x00000007,
  758.         0x8b24, 0xffffffff, 0x00ff0fff,
  759.         0x8b10, 0xffffffff, 0x00000000,
  760.         0x28a4c, 0x06000000, 0x06000000,
  761.         0x4d8, 0xffffffff, 0x00000100,
  762.         0x913c, 0xffff000f, 0x0100000a,
  763.         0x960c, 0xffffffff, 0x54763210,
  764.         0x88c4, 0xffffffff, 0x000000c2,
  765.         0x88d4, 0xffffffff, 0x00000010,
  766.         0x8974, 0xffffffff, 0x00000000,
  767.         0xc78, 0x00000080, 0x00000080,
  768.         0x5e78, 0xffffffff, 0x001000f0,
  769.         0xd02c, 0xffffffff, 0x08421000,
  770.         0xa008, 0xffffffff, 0x00010000,
  771.         0x8d00, 0xffffffff, 0x100e4848,
  772.         0x8d04, 0xffffffff, 0x00164745,
  773.         0x8c00, 0xffffffff, 0xe4000003,
  774.         0x8cf0, 0x1fffffff, 0x08e00620,
  775.         0x28350, 0xffffffff, 0x00000000,
  776.         0x9508, 0xffffffff, 0x00000002
  777. };
  778.  
  779. static const u32 sumo_golden_registers[] =
  780. {
  781.         0x900c, 0x00ffffff, 0x0017071f,
  782.         0x8c18, 0xffffffff, 0x10101060,
  783.         0x8c1c, 0xffffffff, 0x00001010,
  784.         0x8c30, 0x0000000f, 0x00000005,
  785.         0x9688, 0x0000000f, 0x00000007
  786. };
  787.  
  788. static const u32 wrestler_golden_registers[] =
  789. {
  790.         0x5eb4, 0xffffffff, 0x00000002,
  791.         0x5c4, 0xffffffff, 0x00000001,
  792.         0x7030, 0xffffffff, 0x00000011,
  793.         0x7c30, 0xffffffff, 0x00000011,
  794.         0x6104, 0x01000300, 0x00000000,
  795.         0x5bc0, 0x00300000, 0x00000000,
  796.         0x918c, 0xffffffff, 0x00010006,
  797.         0x91a8, 0xffffffff, 0x00010006,
  798.         0x9150, 0xffffffff, 0x6e944040,
  799.         0x917c, 0xffffffff, 0x00030002,
  800.         0x9198, 0xffffffff, 0x00030002,
  801.         0x915c, 0xffffffff, 0x00010000,
  802.         0x3f90, 0xffff0000, 0xff000000,
  803.         0x9178, 0xffffffff, 0x00070000,
  804.         0x9194, 0xffffffff, 0x00070000,
  805.         0x9148, 0xffff0000, 0xff000000,
  806.         0x9190, 0xffffffff, 0x00090008,
  807.         0x91ac, 0xffffffff, 0x00090008,
  808.         0x3f94, 0xffff0000, 0xff000000,
  809.         0x914c, 0xffff0000, 0xff000000,
  810.         0x929c, 0xffffffff, 0x00000001,
  811.         0x8a18, 0xffffffff, 0x00000100,
  812.         0x8b28, 0xffffffff, 0x00000100,
  813.         0x9144, 0xffffffff, 0x00000100,
  814.         0x9b7c, 0xffffffff, 0x00000000,
  815.         0x8030, 0xffffffff, 0x0000100a,
  816.         0x8a14, 0xffffffff, 0x00000001,
  817.         0x8b24, 0xffffffff, 0x00ff0fff,
  818.         0x8b10, 0xffffffff, 0x00000000,
  819.         0x28a4c, 0x06000000, 0x06000000,
  820.         0x4d8, 0xffffffff, 0x00000100,
  821.         0x913c, 0xffff000f, 0x0100000a,
  822.         0x960c, 0xffffffff, 0x54763210,
  823.         0x88c4, 0xffffffff, 0x000000c2,
  824.         0x88d4, 0xffffffff, 0x00000010,
  825.         0x8974, 0xffffffff, 0x00000000,
  826.         0xc78, 0x00000080, 0x00000080,
  827.         0x5e78, 0xffffffff, 0x001000f0,
  828.         0xd02c, 0xffffffff, 0x08421000,
  829.         0xa008, 0xffffffff, 0x00010000,
  830.         0x8d00, 0xffffffff, 0x100e4848,
  831.         0x8d04, 0xffffffff, 0x00164745,
  832.         0x8c00, 0xffffffff, 0xe4000003,
  833.         0x8cf0, 0x1fffffff, 0x08e00410,
  834.         0x28350, 0xffffffff, 0x00000000,
  835.         0x9508, 0xffffffff, 0x00000002,
  836.         0x900c, 0xffffffff, 0x0017071f,
  837.         0x8c18, 0xffffffff, 0x10101060,
  838.         0x8c1c, 0xffffffff, 0x00001010
  839. };
  840.  
  841. static const u32 barts_golden_registers[] =
  842. {
  843.         0x5eb4, 0xffffffff, 0x00000002,
  844.         0x5e78, 0x8f311ff1, 0x001000f0,
  845.         0x3f90, 0xffff0000, 0xff000000,
  846.         0x9148, 0xffff0000, 0xff000000,
  847.         0x3f94, 0xffff0000, 0xff000000,
  848.         0x914c, 0xffff0000, 0xff000000,
  849.         0xc78, 0x00000080, 0x00000080,
  850.         0xbd4, 0x70073777, 0x00010001,
  851.         0xd02c, 0xbfffff1f, 0x08421000,
  852.         0xd0b8, 0x03773777, 0x02011003,
  853.         0x5bc0, 0x00200000, 0x50100000,
  854.         0x98f8, 0x33773777, 0x02011003,
  855.         0x98fc, 0xffffffff, 0x76543210,
  856.         0x7030, 0x31000311, 0x00000011,
  857.         0x2f48, 0x00000007, 0x02011003,
  858.         0x6b28, 0x00000010, 0x00000012,
  859.         0x7728, 0x00000010, 0x00000012,
  860.         0x10328, 0x00000010, 0x00000012,
  861.         0x10f28, 0x00000010, 0x00000012,
  862.         0x11b28, 0x00000010, 0x00000012,
  863.         0x12728, 0x00000010, 0x00000012,
  864.         0x240c, 0x000007ff, 0x00000380,
  865.         0x8a14, 0xf000001f, 0x00000007,
  866.         0x8b24, 0x3fff3fff, 0x00ff0fff,
  867.         0x8b10, 0x0000ff0f, 0x00000000,
  868.         0x28a4c, 0x07ffffff, 0x06000000,
  869.         0x10c, 0x00000001, 0x00010003,
  870.         0xa02c, 0xffffffff, 0x0000009b,
  871.         0x913c, 0x0000000f, 0x0100000a,
  872.         0x8d00, 0xffff7f7f, 0x100e4848,
  873.         0x8d04, 0x00ffffff, 0x00164745,
  874.         0x8c00, 0xfffc0003, 0xe4000003,
  875.         0x8c04, 0xf8ff00ff, 0x40600060,
  876.         0x8c08, 0x00ff00ff, 0x001c001c,
  877.         0x8cf0, 0x1fff1fff, 0x08e00620,
  878.         0x8c20, 0x0fff0fff, 0x00800080,
  879.         0x8c24, 0x0fff0fff, 0x00800080,
  880.         0x8c18, 0xffffffff, 0x20202078,
  881.         0x8c1c, 0x0000ffff, 0x00001010,
  882.         0x28350, 0x00000f01, 0x00000000,
  883.         0x9508, 0x3700001f, 0x00000002,
  884.         0x960c, 0xffffffff, 0x54763210,
  885.         0x88c4, 0x001f3ae3, 0x000000c2,
  886.         0x88d4, 0x0000001f, 0x00000010,
  887.         0x8974, 0xffffffff, 0x00000000
  888. };
  889.  
  890. static const u32 turks_golden_registers[] =
  891. {
  892.         0x5eb4, 0xffffffff, 0x00000002,
  893.         0x5e78, 0x8f311ff1, 0x001000f0,
  894.         0x8c8, 0x00003000, 0x00001070,
  895.         0x8cc, 0x000fffff, 0x00040035,
  896.         0x3f90, 0xffff0000, 0xfff00000,
  897.         0x9148, 0xffff0000, 0xfff00000,
  898.         0x3f94, 0xffff0000, 0xfff00000,
  899.         0x914c, 0xffff0000, 0xfff00000,
  900.         0xc78, 0x00000080, 0x00000080,
  901.         0xbd4, 0x00073007, 0x00010002,
  902.         0xd02c, 0xbfffff1f, 0x08421000,
  903.         0xd0b8, 0x03773777, 0x02010002,
  904.         0x5bc0, 0x00200000, 0x50100000,
  905.         0x98f8, 0x33773777, 0x00010002,
  906.         0x98fc, 0xffffffff, 0x33221100,
  907.         0x7030, 0x31000311, 0x00000011,
  908.         0x2f48, 0x33773777, 0x00010002,
  909.         0x6b28, 0x00000010, 0x00000012,
  910.         0x7728, 0x00000010, 0x00000012,
  911.         0x10328, 0x00000010, 0x00000012,
  912.         0x10f28, 0x00000010, 0x00000012,
  913.         0x11b28, 0x00000010, 0x00000012,
  914.         0x12728, 0x00000010, 0x00000012,
  915.         0x240c, 0x000007ff, 0x00000380,
  916.         0x8a14, 0xf000001f, 0x00000007,
  917.         0x8b24, 0x3fff3fff, 0x00ff0fff,
  918.         0x8b10, 0x0000ff0f, 0x00000000,
  919.         0x28a4c, 0x07ffffff, 0x06000000,
  920.         0x10c, 0x00000001, 0x00010003,
  921.         0xa02c, 0xffffffff, 0x0000009b,
  922.         0x913c, 0x0000000f, 0x0100000a,
  923.         0x8d00, 0xffff7f7f, 0x100e4848,
  924.         0x8d04, 0x00ffffff, 0x00164745,
  925.         0x8c00, 0xfffc0003, 0xe4000003,
  926.         0x8c04, 0xf8ff00ff, 0x40600060,
  927.         0x8c08, 0x00ff00ff, 0x001c001c,
  928.         0x8cf0, 0x1fff1fff, 0x08e00410,
  929.         0x8c20, 0x0fff0fff, 0x00800080,
  930.         0x8c24, 0x0fff0fff, 0x00800080,
  931.         0x8c18, 0xffffffff, 0x20202078,
  932.         0x8c1c, 0x0000ffff, 0x00001010,
  933.         0x28350, 0x00000f01, 0x00000000,
  934.         0x9508, 0x3700001f, 0x00000002,
  935.         0x960c, 0xffffffff, 0x54763210,
  936.         0x88c4, 0x001f3ae3, 0x000000c2,
  937.         0x88d4, 0x0000001f, 0x00000010,
  938.         0x8974, 0xffffffff, 0x00000000
  939. };
  940.  
  941. static const u32 caicos_golden_registers[] =
  942. {
  943.         0x5eb4, 0xffffffff, 0x00000002,
  944.         0x5e78, 0x8f311ff1, 0x001000f0,
  945.         0x8c8, 0x00003420, 0x00001450,
  946.         0x8cc, 0x000fffff, 0x00040035,
  947.         0x3f90, 0xffff0000, 0xfffc0000,
  948.         0x9148, 0xffff0000, 0xfffc0000,
  949.         0x3f94, 0xffff0000, 0xfffc0000,
  950.         0x914c, 0xffff0000, 0xfffc0000,
  951.         0xc78, 0x00000080, 0x00000080,
  952.         0xbd4, 0x00073007, 0x00010001,
  953.         0xd02c, 0xbfffff1f, 0x08421000,
  954.         0xd0b8, 0x03773777, 0x02010001,
  955.         0x5bc0, 0x00200000, 0x50100000,
  956.         0x98f8, 0x33773777, 0x02010001,
  957.         0x98fc, 0xffffffff, 0x33221100,
  958.         0x7030, 0x31000311, 0x00000011,
  959.         0x2f48, 0x33773777, 0x02010001,
  960.         0x6b28, 0x00000010, 0x00000012,
  961.         0x7728, 0x00000010, 0x00000012,
  962.         0x10328, 0x00000010, 0x00000012,
  963.         0x10f28, 0x00000010, 0x00000012,
  964.         0x11b28, 0x00000010, 0x00000012,
  965.         0x12728, 0x00000010, 0x00000012,
  966.         0x240c, 0x000007ff, 0x00000380,
  967.         0x8a14, 0xf000001f, 0x00000001,
  968.         0x8b24, 0x3fff3fff, 0x00ff0fff,
  969.         0x8b10, 0x0000ff0f, 0x00000000,
  970.         0x28a4c, 0x07ffffff, 0x06000000,
  971.         0x10c, 0x00000001, 0x00010003,
  972.         0xa02c, 0xffffffff, 0x0000009b,
  973.         0x913c, 0x0000000f, 0x0100000a,
  974.         0x8d00, 0xffff7f7f, 0x100e4848,
  975.         0x8d04, 0x00ffffff, 0x00164745,
  976.         0x8c00, 0xfffc0003, 0xe4000003,
  977.         0x8c04, 0xf8ff00ff, 0x40600060,
  978.         0x8c08, 0x00ff00ff, 0x001c001c,
  979.         0x8cf0, 0x1fff1fff, 0x08e00410,
  980.         0x8c20, 0x0fff0fff, 0x00800080,
  981.         0x8c24, 0x0fff0fff, 0x00800080,
  982.         0x8c18, 0xffffffff, 0x20202078,
  983.         0x8c1c, 0x0000ffff, 0x00001010,
  984.         0x28350, 0x00000f01, 0x00000000,
  985.         0x9508, 0x3700001f, 0x00000002,
  986.         0x960c, 0xffffffff, 0x54763210,
  987.         0x88c4, 0x001f3ae3, 0x000000c2,
  988.         0x88d4, 0x0000001f, 0x00000010,
  989.         0x8974, 0xffffffff, 0x00000000
  990. };
  991.  
  992. static void evergreen_init_golden_registers(struct radeon_device *rdev)
  993. {
  994.         switch (rdev->family) {
  995.         case CHIP_CYPRESS:
  996.         case CHIP_HEMLOCK:
  997.                 radeon_program_register_sequence(rdev,
  998.                                                  evergreen_golden_registers,
  999.                                                  (const u32)ARRAY_SIZE(evergreen_golden_registers));
  1000.                 radeon_program_register_sequence(rdev,
  1001.                                                  evergreen_golden_registers2,
  1002.                                                  (const u32)ARRAY_SIZE(evergreen_golden_registers2));
  1003.                 radeon_program_register_sequence(rdev,
  1004.                                                  cypress_mgcg_init,
  1005.                                                  (const u32)ARRAY_SIZE(cypress_mgcg_init));
  1006.                 break;
  1007.         case CHIP_JUNIPER:
  1008.                 radeon_program_register_sequence(rdev,
  1009.                                                  evergreen_golden_registers,
  1010.                                                  (const u32)ARRAY_SIZE(evergreen_golden_registers));
  1011.                 radeon_program_register_sequence(rdev,
  1012.                                                  evergreen_golden_registers2,
  1013.                                                  (const u32)ARRAY_SIZE(evergreen_golden_registers2));
  1014.                 radeon_program_register_sequence(rdev,
  1015.                                                  juniper_mgcg_init,
  1016.                                                  (const u32)ARRAY_SIZE(juniper_mgcg_init));
  1017.                 break;
  1018.         case CHIP_REDWOOD:
  1019.                 radeon_program_register_sequence(rdev,
  1020.                                                  evergreen_golden_registers,
  1021.                                                  (const u32)ARRAY_SIZE(evergreen_golden_registers));
  1022.                 radeon_program_register_sequence(rdev,
  1023.                                                  evergreen_golden_registers2,
  1024.                                                  (const u32)ARRAY_SIZE(evergreen_golden_registers2));
  1025.                 radeon_program_register_sequence(rdev,
  1026.                                                  redwood_mgcg_init,
  1027.                                                  (const u32)ARRAY_SIZE(redwood_mgcg_init));
  1028.                 break;
  1029.         case CHIP_CEDAR:
  1030.                 radeon_program_register_sequence(rdev,
  1031.                                                  cedar_golden_registers,
  1032.                                                  (const u32)ARRAY_SIZE(cedar_golden_registers));
  1033.                 radeon_program_register_sequence(rdev,
  1034.                                                  evergreen_golden_registers2,
  1035.                                                  (const u32)ARRAY_SIZE(evergreen_golden_registers2));
  1036.                 radeon_program_register_sequence(rdev,
  1037.                                                  cedar_mgcg_init,
  1038.                                                  (const u32)ARRAY_SIZE(cedar_mgcg_init));
  1039.                 break;
  1040.         case CHIP_PALM:
  1041.                 radeon_program_register_sequence(rdev,
  1042.                                                  wrestler_golden_registers,
  1043.                                                  (const u32)ARRAY_SIZE(wrestler_golden_registers));
  1044.                 break;
  1045.         case CHIP_SUMO:
  1046.                 radeon_program_register_sequence(rdev,
  1047.                                                  supersumo_golden_registers,
  1048.                                                  (const u32)ARRAY_SIZE(supersumo_golden_registers));
  1049.                 break;
  1050.         case CHIP_SUMO2:
  1051.                 radeon_program_register_sequence(rdev,
  1052.                                                  supersumo_golden_registers,
  1053.                                                  (const u32)ARRAY_SIZE(supersumo_golden_registers));
  1054.                 radeon_program_register_sequence(rdev,
  1055.                                                  sumo_golden_registers,
  1056.                                                  (const u32)ARRAY_SIZE(sumo_golden_registers));
  1057.                 break;
  1058.         case CHIP_BARTS:
  1059.                 radeon_program_register_sequence(rdev,
  1060.                                                  barts_golden_registers,
  1061.                                                  (const u32)ARRAY_SIZE(barts_golden_registers));
  1062.                 break;
  1063.         case CHIP_TURKS:
  1064.                 radeon_program_register_sequence(rdev,
  1065.                                                  turks_golden_registers,
  1066.                                                  (const u32)ARRAY_SIZE(turks_golden_registers));
  1067.                 break;
  1068.         case CHIP_CAICOS:
  1069.                 radeon_program_register_sequence(rdev,
  1070.                                                  caicos_golden_registers,
  1071.                                                  (const u32)ARRAY_SIZE(caicos_golden_registers));
  1072.                 break;
  1073.         default:
  1074.                 break;
  1075.         }
  1076. }
  1077.  
  1078. /**
  1079.  * evergreen_get_allowed_info_register - fetch the register for the info ioctl
  1080.  *
  1081.  * @rdev: radeon_device pointer
  1082.  * @reg: register offset in bytes
  1083.  * @val: register value
  1084.  *
  1085.  * Returns 0 for success or -EINVAL for an invalid register
  1086.  *
  1087.  */
  1088. int evergreen_get_allowed_info_register(struct radeon_device *rdev,
  1089.                                         u32 reg, u32 *val)
  1090. {
  1091.         switch (reg) {
  1092.         case GRBM_STATUS:
  1093.         case GRBM_STATUS_SE0:
  1094.         case GRBM_STATUS_SE1:
  1095.         case SRBM_STATUS:
  1096.         case SRBM_STATUS2:
  1097.         case DMA_STATUS_REG:
  1098.         case UVD_STATUS:
  1099.                 *val = RREG32(reg);
  1100.                 return 0;
  1101.         default:
  1102.                 return -EINVAL;
  1103.         }
  1104. }
  1105.  
  1106. void evergreen_tiling_fields(unsigned tiling_flags, unsigned *bankw,
  1107.                              unsigned *bankh, unsigned *mtaspect,
  1108.                              unsigned *tile_split)
  1109. {
  1110.         *bankw = (tiling_flags >> RADEON_TILING_EG_BANKW_SHIFT) & RADEON_TILING_EG_BANKW_MASK;
  1111.         *bankh = (tiling_flags >> RADEON_TILING_EG_BANKH_SHIFT) & RADEON_TILING_EG_BANKH_MASK;
  1112.         *mtaspect = (tiling_flags >> RADEON_TILING_EG_MACRO_TILE_ASPECT_SHIFT) & RADEON_TILING_EG_MACRO_TILE_ASPECT_MASK;
  1113.         *tile_split = (tiling_flags >> RADEON_TILING_EG_TILE_SPLIT_SHIFT) & RADEON_TILING_EG_TILE_SPLIT_MASK;
  1114.         switch (*bankw) {
  1115.         default:
  1116.         case 1: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_1; break;
  1117.         case 2: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_2; break;
  1118.         case 4: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_4; break;
  1119.         case 8: *bankw = EVERGREEN_ADDR_SURF_BANK_WIDTH_8; break;
  1120.         }
  1121.         switch (*bankh) {
  1122.         default:
  1123.         case 1: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_1; break;
  1124.         case 2: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_2; break;
  1125.         case 4: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_4; break;
  1126.         case 8: *bankh = EVERGREEN_ADDR_SURF_BANK_HEIGHT_8; break;
  1127.         }
  1128.         switch (*mtaspect) {
  1129.         default:
  1130.         case 1: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_1; break;
  1131.         case 2: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_2; break;
  1132.         case 4: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_4; break;
  1133.         case 8: *mtaspect = EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_8; break;
  1134.         }
  1135. }
  1136.  
  1137. static int sumo_set_uvd_clock(struct radeon_device *rdev, u32 clock,
  1138.                               u32 cntl_reg, u32 status_reg)
  1139. {
  1140.         int r, i;
  1141.         struct atom_clock_dividers dividers;
  1142.  
  1143.         r = radeon_atom_get_clock_dividers(rdev, COMPUTE_ENGINE_PLL_PARAM,
  1144.                                            clock, false, &dividers);
  1145.         if (r)
  1146.                 return r;
  1147.  
  1148.         WREG32_P(cntl_reg, dividers.post_div, ~(DCLK_DIR_CNTL_EN|DCLK_DIVIDER_MASK));
  1149.  
  1150.         for (i = 0; i < 100; i++) {
  1151.                 if (RREG32(status_reg) & DCLK_STATUS)
  1152.                         break;
  1153.                 mdelay(10);
  1154.         }
  1155.         if (i == 100)
  1156.                 return -ETIMEDOUT;
  1157.  
  1158.         return 0;
  1159. }
  1160.  
  1161. int sumo_set_uvd_clocks(struct radeon_device *rdev, u32 vclk, u32 dclk)
  1162. {
  1163.         int r = 0;
  1164.         u32 cg_scratch = RREG32(CG_SCRATCH1);
  1165.  
  1166.         r = sumo_set_uvd_clock(rdev, vclk, CG_VCLK_CNTL, CG_VCLK_STATUS);
  1167.         if (r)
  1168.                 goto done;
  1169.         cg_scratch &= 0xffff0000;
  1170.         cg_scratch |= vclk / 100; /* Mhz */
  1171.  
  1172.         r = sumo_set_uvd_clock(rdev, dclk, CG_DCLK_CNTL, CG_DCLK_STATUS);
  1173.         if (r)
  1174.                 goto done;
  1175.         cg_scratch &= 0x0000ffff;
  1176.         cg_scratch |= (dclk / 100) << 16; /* Mhz */
  1177.  
  1178. done:
  1179.         WREG32(CG_SCRATCH1, cg_scratch);
  1180.  
  1181.         return r;
  1182. }
  1183.  
  1184. int evergreen_set_uvd_clocks(struct radeon_device *rdev, u32 vclk, u32 dclk)
  1185. {
  1186.         /* start off with something large */
  1187.         unsigned fb_div = 0, vclk_div = 0, dclk_div = 0;
  1188.         int r;
  1189.  
  1190.         /* bypass vclk and dclk with bclk */
  1191.         WREG32_P(CG_UPLL_FUNC_CNTL_2,
  1192.                 VCLK_SRC_SEL(1) | DCLK_SRC_SEL(1),
  1193.                 ~(VCLK_SRC_SEL_MASK | DCLK_SRC_SEL_MASK));
  1194.  
  1195.         /* put PLL in bypass mode */
  1196.         WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_BYPASS_EN_MASK, ~UPLL_BYPASS_EN_MASK);
  1197.  
  1198.         if (!vclk || !dclk) {
  1199.                 /* keep the Bypass mode, put PLL to sleep */
  1200.                 WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_SLEEP_MASK, ~UPLL_SLEEP_MASK);
  1201.                 return 0;
  1202.         }
  1203.  
  1204.         r = radeon_uvd_calc_upll_dividers(rdev, vclk, dclk, 125000, 250000,
  1205.                                           16384, 0x03FFFFFF, 0, 128, 5,
  1206.                                           &fb_div, &vclk_div, &dclk_div);
  1207.         if (r)
  1208.                 return r;
  1209.  
  1210.         /* set VCO_MODE to 1 */
  1211.         WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_VCO_MODE_MASK, ~UPLL_VCO_MODE_MASK);
  1212.  
  1213.         /* toggle UPLL_SLEEP to 1 then back to 0 */
  1214.         WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_SLEEP_MASK, ~UPLL_SLEEP_MASK);
  1215.         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_SLEEP_MASK);
  1216.  
  1217.         /* deassert UPLL_RESET */
  1218.         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_RESET_MASK);
  1219.  
  1220.         mdelay(1);
  1221.  
  1222.         r = radeon_uvd_send_upll_ctlreq(rdev, CG_UPLL_FUNC_CNTL);
  1223.         if (r)
  1224.                 return r;
  1225.  
  1226.         /* assert UPLL_RESET again */
  1227.         WREG32_P(CG_UPLL_FUNC_CNTL, UPLL_RESET_MASK, ~UPLL_RESET_MASK);
  1228.  
  1229.         /* disable spread spectrum. */
  1230.         WREG32_P(CG_UPLL_SPREAD_SPECTRUM, 0, ~SSEN_MASK);
  1231.  
  1232.         /* set feedback divider */
  1233.         WREG32_P(CG_UPLL_FUNC_CNTL_3, UPLL_FB_DIV(fb_div), ~UPLL_FB_DIV_MASK);
  1234.  
  1235.         /* set ref divider to 0 */
  1236.         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_REF_DIV_MASK);
  1237.  
  1238.         if (fb_div < 307200)
  1239.                 WREG32_P(CG_UPLL_FUNC_CNTL_4, 0, ~UPLL_SPARE_ISPARE9);
  1240.         else
  1241.                 WREG32_P(CG_UPLL_FUNC_CNTL_4, UPLL_SPARE_ISPARE9, ~UPLL_SPARE_ISPARE9);
  1242.  
  1243.         /* set PDIV_A and PDIV_B */
  1244.         WREG32_P(CG_UPLL_FUNC_CNTL_2,
  1245.                 UPLL_PDIV_A(vclk_div) | UPLL_PDIV_B(dclk_div),
  1246.                 ~(UPLL_PDIV_A_MASK | UPLL_PDIV_B_MASK));
  1247.  
  1248.         /* give the PLL some time to settle */
  1249.         mdelay(15);
  1250.  
  1251.         /* deassert PLL_RESET */
  1252.         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_RESET_MASK);
  1253.  
  1254.         mdelay(15);
  1255.  
  1256.         /* switch from bypass mode to normal mode */
  1257.         WREG32_P(CG_UPLL_FUNC_CNTL, 0, ~UPLL_BYPASS_EN_MASK);
  1258.  
  1259.         r = radeon_uvd_send_upll_ctlreq(rdev, CG_UPLL_FUNC_CNTL);
  1260.         if (r)
  1261.                 return r;
  1262.  
  1263.         /* switch VCLK and DCLK selection */
  1264.         WREG32_P(CG_UPLL_FUNC_CNTL_2,
  1265.                 VCLK_SRC_SEL(2) | DCLK_SRC_SEL(2),
  1266.                 ~(VCLK_SRC_SEL_MASK | DCLK_SRC_SEL_MASK));
  1267.  
  1268.         mdelay(100);
  1269.  
  1270.         return 0;
  1271. }
  1272.  
  1273. void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
  1274. {
  1275.         int readrq;
  1276.         u16 v;
  1277.  
  1278.         readrq = pcie_get_readrq(rdev->pdev);
  1279.         v = ffs(readrq) - 8;
  1280.         /* if bios or OS sets MAX_READ_REQUEST_SIZE to an invalid value, fix it
  1281.          * to avoid hangs or perfomance issues
  1282.          */
  1283.         if ((v == 0) || (v == 6) || (v == 7))
  1284.                 pcie_set_readrq(rdev->pdev, 512);
  1285. }
  1286.  
  1287. void dce4_program_fmt(struct drm_encoder *encoder)
  1288. {
  1289.         struct drm_device *dev = encoder->dev;
  1290.         struct radeon_device *rdev = dev->dev_private;
  1291.         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
  1292.         struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
  1293.         struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
  1294.         int bpc = 0;
  1295.         u32 tmp = 0;
  1296.         enum radeon_connector_dither dither = RADEON_FMT_DITHER_DISABLE;
  1297.  
  1298.         if (connector) {
  1299.                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1300.                 bpc = radeon_get_monitor_bpc(connector);
  1301.                 dither = radeon_connector->dither;
  1302.         }
  1303.  
  1304.         /* LVDS/eDP FMT is set up by atom */
  1305.         if (radeon_encoder->devices & ATOM_DEVICE_LCD_SUPPORT)
  1306.                 return;
  1307.  
  1308.         /* not needed for analog */
  1309.         if ((radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC1) ||
  1310.             (radeon_encoder->encoder_id == ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DAC2))
  1311.                 return;
  1312.  
  1313.         if (bpc == 0)
  1314.                 return;
  1315.  
  1316.         switch (bpc) {
  1317.         case 6:
  1318.                 if (dither == RADEON_FMT_DITHER_ENABLE)
  1319.                         /* XXX sort out optimal dither settings */
  1320.                         tmp |= (FMT_FRAME_RANDOM_ENABLE | FMT_HIGHPASS_RANDOM_ENABLE |
  1321.                                 FMT_SPATIAL_DITHER_EN);
  1322.                 else
  1323.                         tmp |= FMT_TRUNCATE_EN;
  1324.                 break;
  1325.         case 8:
  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_RGB_RANDOM_ENABLE |
  1330.                                 FMT_SPATIAL_DITHER_EN | FMT_SPATIAL_DITHER_DEPTH);
  1331.                 else
  1332.                         tmp |= (FMT_TRUNCATE_EN | FMT_TRUNCATE_DEPTH);
  1333.                 break;
  1334.         case 10:
  1335.         default:
  1336.                 /* not needed */
  1337.                 break;
  1338.         }
  1339.  
  1340.         WREG32(FMT_BIT_DEPTH_CONTROL + radeon_crtc->crtc_offset, tmp);
  1341. }
  1342.  
  1343. static bool dce4_is_in_vblank(struct radeon_device *rdev, int crtc)
  1344. {
  1345.         if (RREG32(EVERGREEN_CRTC_STATUS + crtc_offsets[crtc]) & EVERGREEN_CRTC_V_BLANK)
  1346.                 return true;
  1347.         else
  1348.                 return false;
  1349. }
  1350.  
  1351. static bool dce4_is_counter_moving(struct radeon_device *rdev, int crtc)
  1352. {
  1353.         u32 pos1, pos2;
  1354.  
  1355.         pos1 = RREG32(EVERGREEN_CRTC_STATUS_POSITION + crtc_offsets[crtc]);
  1356.         pos2 = RREG32(EVERGREEN_CRTC_STATUS_POSITION + crtc_offsets[crtc]);
  1357.  
  1358.         if (pos1 != pos2)
  1359.                 return true;
  1360.         else
  1361.                 return false;
  1362. }
  1363.  
  1364. /**
  1365.  * dce4_wait_for_vblank - vblank wait asic callback.
  1366.  *
  1367.  * @rdev: radeon_device pointer
  1368.  * @crtc: crtc to wait for vblank on
  1369.  *
  1370.  * Wait for vblank on the requested crtc (evergreen+).
  1371.  */
  1372. void dce4_wait_for_vblank(struct radeon_device *rdev, int crtc)
  1373. {
  1374.         unsigned i = 0;
  1375.  
  1376.         if (crtc >= rdev->num_crtc)
  1377.                 return;
  1378.  
  1379.         if (!(RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[crtc]) & EVERGREEN_CRTC_MASTER_EN))
  1380.                 return;
  1381.  
  1382.         /* depending on when we hit vblank, we may be close to active; if so,
  1383.          * wait for another frame.
  1384.          */
  1385.         while (dce4_is_in_vblank(rdev, crtc)) {
  1386.                 if (i++ % 100 == 0) {
  1387.                         if (!dce4_is_counter_moving(rdev, crtc))
  1388.                                 break;
  1389.                 }
  1390.         }
  1391.  
  1392.         while (!dce4_is_in_vblank(rdev, crtc)) {
  1393.                 if (i++ % 100 == 0) {
  1394.                         if (!dce4_is_counter_moving(rdev, crtc))
  1395.                                 break;
  1396.                 }
  1397.         }
  1398. }
  1399.  
  1400. /**
  1401.  * evergreen_page_flip - pageflip callback.
  1402.  *
  1403.  * @rdev: radeon_device pointer
  1404.  * @crtc_id: crtc to cleanup pageflip on
  1405.  * @crtc_base: new address of the crtc (GPU MC address)
  1406.  *
  1407.  * Triggers the actual pageflip by updating the primary
  1408.  * surface base address (evergreen+).
  1409.  */
  1410. void evergreen_page_flip(struct radeon_device *rdev, int crtc_id, u64 crtc_base)
  1411. {
  1412.         struct radeon_crtc *radeon_crtc = rdev->mode_info.crtcs[crtc_id];
  1413.  
  1414.         /* update the scanout addresses */
  1415.         WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS_HIGH + radeon_crtc->crtc_offset,
  1416.                upper_32_bits(crtc_base));
  1417.         WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS + radeon_crtc->crtc_offset,
  1418.                (u32)crtc_base);
  1419.         /* post the write */
  1420.         RREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS + radeon_crtc->crtc_offset);
  1421. }
  1422.  
  1423. /**
  1424.  * evergreen_page_flip_pending - check if page flip is still pending
  1425.  *
  1426.  * @rdev: radeon_device pointer
  1427.  * @crtc_id: crtc to check
  1428.  *
  1429.  * Returns the current update pending status.
  1430.  */
  1431. bool evergreen_page_flip_pending(struct radeon_device *rdev, int crtc_id)
  1432. {
  1433.         struct radeon_crtc *radeon_crtc = rdev->mode_info.crtcs[crtc_id];
  1434.  
  1435.         /* Return current update_pending status: */
  1436.         return !!(RREG32(EVERGREEN_GRPH_UPDATE + radeon_crtc->crtc_offset) &
  1437.                 EVERGREEN_GRPH_SURFACE_UPDATE_PENDING);
  1438. }
  1439.  
  1440. /* get temperature in millidegrees */
  1441. int evergreen_get_temp(struct radeon_device *rdev)
  1442. {
  1443.         u32 temp, toffset;
  1444.         int actual_temp = 0;
  1445.  
  1446.         if (rdev->family == CHIP_JUNIPER) {
  1447.                 toffset = (RREG32(CG_THERMAL_CTRL) & TOFFSET_MASK) >>
  1448.                         TOFFSET_SHIFT;
  1449.                 temp = (RREG32(CG_TS0_STATUS) & TS0_ADC_DOUT_MASK) >>
  1450.                         TS0_ADC_DOUT_SHIFT;
  1451.  
  1452.                 if (toffset & 0x100)
  1453.                         actual_temp = temp / 2 - (0x200 - toffset);
  1454.                 else
  1455.                         actual_temp = temp / 2 + toffset;
  1456.  
  1457.                 actual_temp = actual_temp * 1000;
  1458.  
  1459.         } else {
  1460.                 temp = (RREG32(CG_MULT_THERMAL_STATUS) & ASIC_T_MASK) >>
  1461.                         ASIC_T_SHIFT;
  1462.  
  1463.                 if (temp & 0x400)
  1464.                         actual_temp = -256;
  1465.                 else if (temp & 0x200)
  1466.                         actual_temp = 255;
  1467.                 else if (temp & 0x100) {
  1468.                         actual_temp = temp & 0x1ff;
  1469.                         actual_temp |= ~0x1ff;
  1470.                 } else
  1471.                         actual_temp = temp & 0xff;
  1472.  
  1473.                 actual_temp = (actual_temp * 1000) / 2;
  1474.         }
  1475.  
  1476.         return actual_temp;
  1477. }
  1478.  
  1479. int sumo_get_temp(struct radeon_device *rdev)
  1480. {
  1481.         u32 temp = RREG32(CG_THERMAL_STATUS) & 0xff;
  1482.         int actual_temp = temp - 49;
  1483.  
  1484.         return actual_temp * 1000;
  1485. }
  1486.  
  1487. /**
  1488.  * sumo_pm_init_profile - Initialize power profiles callback.
  1489.  *
  1490.  * @rdev: radeon_device pointer
  1491.  *
  1492.  * Initialize the power states used in profile mode
  1493.  * (sumo, trinity, SI).
  1494.  * Used for profile mode only.
  1495.  */
  1496. void sumo_pm_init_profile(struct radeon_device *rdev)
  1497. {
  1498.         int idx;
  1499.  
  1500.         /* default */
  1501.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_ps_idx = rdev->pm.default_power_state_index;
  1502.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_ps_idx = rdev->pm.default_power_state_index;
  1503.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_cm_idx = 0;
  1504.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_cm_idx = 0;
  1505.  
  1506.         /* low,mid sh/mh */
  1507.         if (rdev->flags & RADEON_IS_MOBILITY)
  1508.                 idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_BATTERY, 0);
  1509.         else
  1510.                 idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_PERFORMANCE, 0);
  1511.  
  1512.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_ps_idx = idx;
  1513.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_ps_idx = idx;
  1514.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_cm_idx = 0;
  1515.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_cm_idx = 0;
  1516.  
  1517.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_ps_idx = idx;
  1518.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_ps_idx = idx;
  1519.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_cm_idx = 0;
  1520.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_cm_idx = 0;
  1521.  
  1522.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_ps_idx = idx;
  1523.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_ps_idx = idx;
  1524.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_cm_idx = 0;
  1525.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_cm_idx = 0;
  1526.  
  1527.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_ps_idx = idx;
  1528.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_ps_idx = idx;
  1529.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_cm_idx = 0;
  1530.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_cm_idx = 0;
  1531.  
  1532.         /* high sh/mh */
  1533.         idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_PERFORMANCE, 0);
  1534.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_ps_idx = idx;
  1535.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_ps_idx = idx;
  1536.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_cm_idx = 0;
  1537.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_cm_idx =
  1538.                 rdev->pm.power_state[idx].num_clock_modes - 1;
  1539.  
  1540.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_ps_idx = idx;
  1541.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_ps_idx = idx;
  1542.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_cm_idx = 0;
  1543.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_cm_idx =
  1544.                 rdev->pm.power_state[idx].num_clock_modes - 1;
  1545. }
  1546.  
  1547. /**
  1548.  * btc_pm_init_profile - Initialize power profiles callback.
  1549.  *
  1550.  * @rdev: radeon_device pointer
  1551.  *
  1552.  * Initialize the power states used in profile mode
  1553.  * (BTC, cayman).
  1554.  * Used for profile mode only.
  1555.  */
  1556. void btc_pm_init_profile(struct radeon_device *rdev)
  1557. {
  1558.         int idx;
  1559.  
  1560.         /* default */
  1561.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_ps_idx = rdev->pm.default_power_state_index;
  1562.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_ps_idx = rdev->pm.default_power_state_index;
  1563.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_off_cm_idx = 0;
  1564.         rdev->pm.profiles[PM_PROFILE_DEFAULT_IDX].dpms_on_cm_idx = 2;
  1565.         /* starting with BTC, there is one state that is used for both
  1566.          * MH and SH.  Difference is that we always use the high clock index for
  1567.          * mclk.
  1568.          */
  1569.         if (rdev->flags & RADEON_IS_MOBILITY)
  1570.                 idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_BATTERY, 0);
  1571.         else
  1572.                 idx = radeon_pm_get_type_index(rdev, POWER_STATE_TYPE_PERFORMANCE, 0);
  1573.         /* low sh */
  1574.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_ps_idx = idx;
  1575.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_ps_idx = idx;
  1576.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_off_cm_idx = 0;
  1577.         rdev->pm.profiles[PM_PROFILE_LOW_SH_IDX].dpms_on_cm_idx = 0;
  1578.         /* mid sh */
  1579.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_ps_idx = idx;
  1580.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_ps_idx = idx;
  1581.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_off_cm_idx = 0;
  1582.         rdev->pm.profiles[PM_PROFILE_MID_SH_IDX].dpms_on_cm_idx = 1;
  1583.         /* high sh */
  1584.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_ps_idx = idx;
  1585.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_ps_idx = idx;
  1586.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_off_cm_idx = 0;
  1587.         rdev->pm.profiles[PM_PROFILE_HIGH_SH_IDX].dpms_on_cm_idx = 2;
  1588.         /* low mh */
  1589.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_ps_idx = idx;
  1590.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_ps_idx = idx;
  1591.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_off_cm_idx = 0;
  1592.         rdev->pm.profiles[PM_PROFILE_LOW_MH_IDX].dpms_on_cm_idx = 0;
  1593.         /* mid mh */
  1594.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_ps_idx = idx;
  1595.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_ps_idx = idx;
  1596.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_off_cm_idx = 0;
  1597.         rdev->pm.profiles[PM_PROFILE_MID_MH_IDX].dpms_on_cm_idx = 1;
  1598.         /* high mh */
  1599.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_ps_idx = idx;
  1600.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_ps_idx = idx;
  1601.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_off_cm_idx = 0;
  1602.         rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_cm_idx = 2;
  1603. }
  1604.  
  1605. /**
  1606.  * evergreen_pm_misc - set additional pm hw parameters callback.
  1607.  *
  1608.  * @rdev: radeon_device pointer
  1609.  *
  1610.  * Set non-clock parameters associated with a power state
  1611.  * (voltage, etc.) (evergreen+).
  1612.  */
  1613. void evergreen_pm_misc(struct radeon_device *rdev)
  1614. {
  1615.         int req_ps_idx = rdev->pm.requested_power_state_index;
  1616.         int req_cm_idx = rdev->pm.requested_clock_mode_index;
  1617.         struct radeon_power_state *ps = &rdev->pm.power_state[req_ps_idx];
  1618.         struct radeon_voltage *voltage = &ps->clock_info[req_cm_idx].voltage;
  1619.  
  1620.         if (voltage->type == VOLTAGE_SW) {
  1621.                 /* 0xff0x are flags rather then an actual voltage */
  1622.                 if ((voltage->voltage & 0xff00) == 0xff00)
  1623.                         return;
  1624.                 if (voltage->voltage && (voltage->voltage != rdev->pm.current_vddc)) {
  1625.                         radeon_atom_set_voltage(rdev, voltage->voltage, SET_VOLTAGE_TYPE_ASIC_VDDC);
  1626.                         rdev->pm.current_vddc = voltage->voltage;
  1627.                         DRM_DEBUG("Setting: vddc: %d\n", voltage->voltage);
  1628.                 }
  1629.  
  1630.                 /* starting with BTC, there is one state that is used for both
  1631.                  * MH and SH.  Difference is that we always use the high clock index for
  1632.                  * mclk and vddci.
  1633.                  */
  1634.                 if ((rdev->pm.pm_method == PM_METHOD_PROFILE) &&
  1635.                     (rdev->family >= CHIP_BARTS) &&
  1636.                     rdev->pm.active_crtc_count &&
  1637.                     ((rdev->pm.profile_index == PM_PROFILE_MID_MH_IDX) ||
  1638.                      (rdev->pm.profile_index == PM_PROFILE_LOW_MH_IDX)))
  1639.                         voltage = &rdev->pm.power_state[req_ps_idx].
  1640.                                 clock_info[rdev->pm.profiles[PM_PROFILE_HIGH_MH_IDX].dpms_on_cm_idx].voltage;
  1641.  
  1642.                 /* 0xff0x are flags rather then an actual voltage */
  1643.                 if ((voltage->vddci & 0xff00) == 0xff00)
  1644.                         return;
  1645.                 if (voltage->vddci && (voltage->vddci != rdev->pm.current_vddci)) {
  1646.                         radeon_atom_set_voltage(rdev, voltage->vddci, SET_VOLTAGE_TYPE_ASIC_VDDCI);
  1647.                         rdev->pm.current_vddci = voltage->vddci;
  1648.                         DRM_DEBUG("Setting: vddci: %d\n", voltage->vddci);
  1649.                 }
  1650.         }
  1651. }
  1652.  
  1653. /**
  1654.  * evergreen_pm_prepare - pre-power state change callback.
  1655.  *
  1656.  * @rdev: radeon_device pointer
  1657.  *
  1658.  * Prepare for a power state change (evergreen+).
  1659.  */
  1660. void evergreen_pm_prepare(struct radeon_device *rdev)
  1661. {
  1662.         struct drm_device *ddev = rdev->ddev;
  1663.         struct drm_crtc *crtc;
  1664.         struct radeon_crtc *radeon_crtc;
  1665.         u32 tmp;
  1666.  
  1667.         /* disable any active CRTCs */
  1668.         list_for_each_entry(crtc, &ddev->mode_config.crtc_list, head) {
  1669.                 radeon_crtc = to_radeon_crtc(crtc);
  1670.                 if (radeon_crtc->enabled) {
  1671.                         tmp = RREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset);
  1672.                         tmp |= EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE;
  1673.                         WREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset, tmp);
  1674.                 }
  1675.         }
  1676. }
  1677.  
  1678. /**
  1679.  * evergreen_pm_finish - post-power state change callback.
  1680.  *
  1681.  * @rdev: radeon_device pointer
  1682.  *
  1683.  * Clean up after a power state change (evergreen+).
  1684.  */
  1685. void evergreen_pm_finish(struct radeon_device *rdev)
  1686. {
  1687.         struct drm_device *ddev = rdev->ddev;
  1688.         struct drm_crtc *crtc;
  1689.         struct radeon_crtc *radeon_crtc;
  1690.         u32 tmp;
  1691.  
  1692.         /* enable any active CRTCs */
  1693.         list_for_each_entry(crtc, &ddev->mode_config.crtc_list, head) {
  1694.                 radeon_crtc = to_radeon_crtc(crtc);
  1695.                 if (radeon_crtc->enabled) {
  1696.                         tmp = RREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset);
  1697.                         tmp &= ~EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE;
  1698.                         WREG32(EVERGREEN_CRTC_CONTROL + radeon_crtc->crtc_offset, tmp);
  1699.                 }
  1700.         }
  1701. }
  1702.  
  1703. /**
  1704.  * evergreen_hpd_sense - hpd sense callback.
  1705.  *
  1706.  * @rdev: radeon_device pointer
  1707.  * @hpd: hpd (hotplug detect) pin
  1708.  *
  1709.  * Checks if a digital monitor is connected (evergreen+).
  1710.  * Returns true if connected, false if not connected.
  1711.  */
  1712. bool evergreen_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd)
  1713. {
  1714.         bool connected = false;
  1715.  
  1716.         switch (hpd) {
  1717.         case RADEON_HPD_1:
  1718.                 if (RREG32(DC_HPD1_INT_STATUS) & DC_HPDx_SENSE)
  1719.                         connected = true;
  1720.                 break;
  1721.         case RADEON_HPD_2:
  1722.                 if (RREG32(DC_HPD2_INT_STATUS) & DC_HPDx_SENSE)
  1723.                         connected = true;
  1724.                 break;
  1725.         case RADEON_HPD_3:
  1726.                 if (RREG32(DC_HPD3_INT_STATUS) & DC_HPDx_SENSE)
  1727.                         connected = true;
  1728.                 break;
  1729.         case RADEON_HPD_4:
  1730.                 if (RREG32(DC_HPD4_INT_STATUS) & DC_HPDx_SENSE)
  1731.                         connected = true;
  1732.                 break;
  1733.         case RADEON_HPD_5:
  1734.                 if (RREG32(DC_HPD5_INT_STATUS) & DC_HPDx_SENSE)
  1735.                         connected = true;
  1736.                 break;
  1737.         case RADEON_HPD_6:
  1738.                 if (RREG32(DC_HPD6_INT_STATUS) & DC_HPDx_SENSE)
  1739.                         connected = true;
  1740.                 break;
  1741.         default:
  1742.                 break;
  1743.         }
  1744.  
  1745.         return connected;
  1746. }
  1747.  
  1748. /**
  1749.  * evergreen_hpd_set_polarity - hpd set polarity callback.
  1750.  *
  1751.  * @rdev: radeon_device pointer
  1752.  * @hpd: hpd (hotplug detect) pin
  1753.  *
  1754.  * Set the polarity of the hpd pin (evergreen+).
  1755.  */
  1756. void evergreen_hpd_set_polarity(struct radeon_device *rdev,
  1757.                                 enum radeon_hpd_id hpd)
  1758. {
  1759.         u32 tmp;
  1760.         bool connected = evergreen_hpd_sense(rdev, hpd);
  1761.  
  1762.         switch (hpd) {
  1763.         case RADEON_HPD_1:
  1764.                 tmp = RREG32(DC_HPD1_INT_CONTROL);
  1765.                 if (connected)
  1766.                         tmp &= ~DC_HPDx_INT_POLARITY;
  1767.                 else
  1768.                         tmp |= DC_HPDx_INT_POLARITY;
  1769.                 WREG32(DC_HPD1_INT_CONTROL, tmp);
  1770.                 break;
  1771.         case RADEON_HPD_2:
  1772.                 tmp = RREG32(DC_HPD2_INT_CONTROL);
  1773.                 if (connected)
  1774.                         tmp &= ~DC_HPDx_INT_POLARITY;
  1775.                 else
  1776.                         tmp |= DC_HPDx_INT_POLARITY;
  1777.                 WREG32(DC_HPD2_INT_CONTROL, tmp);
  1778.                 break;
  1779.         case RADEON_HPD_3:
  1780.                 tmp = RREG32(DC_HPD3_INT_CONTROL);
  1781.                 if (connected)
  1782.                         tmp &= ~DC_HPDx_INT_POLARITY;
  1783.                 else
  1784.                         tmp |= DC_HPDx_INT_POLARITY;
  1785.                 WREG32(DC_HPD3_INT_CONTROL, tmp);
  1786.                 break;
  1787.         case RADEON_HPD_4:
  1788.                 tmp = RREG32(DC_HPD4_INT_CONTROL);
  1789.                 if (connected)
  1790.                         tmp &= ~DC_HPDx_INT_POLARITY;
  1791.                 else
  1792.                         tmp |= DC_HPDx_INT_POLARITY;
  1793.                 WREG32(DC_HPD4_INT_CONTROL, tmp);
  1794.                 break;
  1795.         case RADEON_HPD_5:
  1796.                 tmp = RREG32(DC_HPD5_INT_CONTROL);
  1797.                 if (connected)
  1798.                         tmp &= ~DC_HPDx_INT_POLARITY;
  1799.                 else
  1800.                         tmp |= DC_HPDx_INT_POLARITY;
  1801.                 WREG32(DC_HPD5_INT_CONTROL, tmp);
  1802.                         break;
  1803.         case RADEON_HPD_6:
  1804.                 tmp = RREG32(DC_HPD6_INT_CONTROL);
  1805.                 if (connected)
  1806.                         tmp &= ~DC_HPDx_INT_POLARITY;
  1807.                 else
  1808.                         tmp |= DC_HPDx_INT_POLARITY;
  1809.                 WREG32(DC_HPD6_INT_CONTROL, tmp);
  1810.                 break;
  1811.         default:
  1812.                 break;
  1813.         }
  1814. }
  1815.  
  1816. /**
  1817.  * evergreen_hpd_init - hpd setup callback.
  1818.  *
  1819.  * @rdev: radeon_device pointer
  1820.  *
  1821.  * Setup the hpd pins used by the card (evergreen+).
  1822.  * Enable the pin, set the polarity, and enable the hpd interrupts.
  1823.  */
  1824. void evergreen_hpd_init(struct radeon_device *rdev)
  1825. {
  1826.         struct drm_device *dev = rdev->ddev;
  1827.         struct drm_connector *connector;
  1828.         unsigned enabled = 0;
  1829.         u32 tmp = DC_HPDx_CONNECTION_TIMER(0x9c4) |
  1830.                 DC_HPDx_RX_INT_TIMER(0xfa) | DC_HPDx_EN;
  1831.  
  1832.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1833.                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1834.  
  1835.                 if (connector->connector_type == DRM_MODE_CONNECTOR_eDP ||
  1836.                     connector->connector_type == DRM_MODE_CONNECTOR_LVDS) {
  1837.                         /* don't try to enable hpd on eDP or LVDS avoid breaking the
  1838.                          * aux dp channel on imac and help (but not completely fix)
  1839.                          * https://bugzilla.redhat.com/show_bug.cgi?id=726143
  1840.                          * also avoid interrupt storms during dpms.
  1841.                          */
  1842.                         continue;
  1843.                 }
  1844.                 switch (radeon_connector->hpd.hpd) {
  1845.                 case RADEON_HPD_1:
  1846.                         WREG32(DC_HPD1_CONTROL, tmp);
  1847.                         break;
  1848.                 case RADEON_HPD_2:
  1849.                         WREG32(DC_HPD2_CONTROL, tmp);
  1850.                         break;
  1851.                 case RADEON_HPD_3:
  1852.                         WREG32(DC_HPD3_CONTROL, tmp);
  1853.                         break;
  1854.                 case RADEON_HPD_4:
  1855.                         WREG32(DC_HPD4_CONTROL, tmp);
  1856.                         break;
  1857.                 case RADEON_HPD_5:
  1858.                         WREG32(DC_HPD5_CONTROL, tmp);
  1859.                         break;
  1860.                 case RADEON_HPD_6:
  1861.                         WREG32(DC_HPD6_CONTROL, tmp);
  1862.                         break;
  1863.                 default:
  1864.                         break;
  1865.                 }
  1866.                 radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
  1867.                 enabled |= 1 << radeon_connector->hpd.hpd;
  1868.         }
  1869. //   radeon_irq_kms_enable_hpd(rdev, enabled);
  1870. }
  1871.  
  1872. /**
  1873.  * evergreen_hpd_fini - hpd tear down callback.
  1874.  *
  1875.  * @rdev: radeon_device pointer
  1876.  *
  1877.  * Tear down the hpd pins used by the card (evergreen+).
  1878.  * Disable the hpd interrupts.
  1879.  */
  1880. void evergreen_hpd_fini(struct radeon_device *rdev)
  1881. {
  1882.         struct drm_device *dev = rdev->ddev;
  1883.         struct drm_connector *connector;
  1884.         unsigned disabled = 0;
  1885.  
  1886.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1887.                 struct radeon_connector *radeon_connector = to_radeon_connector(connector);
  1888.                 switch (radeon_connector->hpd.hpd) {
  1889.                 case RADEON_HPD_1:
  1890.                         WREG32(DC_HPD1_CONTROL, 0);
  1891.                         break;
  1892.                 case RADEON_HPD_2:
  1893.                         WREG32(DC_HPD2_CONTROL, 0);
  1894.                         break;
  1895.                 case RADEON_HPD_3:
  1896.                         WREG32(DC_HPD3_CONTROL, 0);
  1897.                         break;
  1898.                 case RADEON_HPD_4:
  1899.                         WREG32(DC_HPD4_CONTROL, 0);
  1900.                         break;
  1901.                 case RADEON_HPD_5:
  1902.                         WREG32(DC_HPD5_CONTROL, 0);
  1903.                         break;
  1904.                 case RADEON_HPD_6:
  1905.                         WREG32(DC_HPD6_CONTROL, 0);
  1906.                         break;
  1907.                 default:
  1908.                         break;
  1909.                 }
  1910.                 disabled |= 1 << radeon_connector->hpd.hpd;
  1911.         }
  1912. //   radeon_irq_kms_disable_hpd(rdev, disabled);
  1913. }
  1914.  
  1915. /* watermark setup */
  1916.  
  1917. static u32 evergreen_line_buffer_adjust(struct radeon_device *rdev,
  1918.                                         struct radeon_crtc *radeon_crtc,
  1919.                                         struct drm_display_mode *mode,
  1920.                                         struct drm_display_mode *other_mode)
  1921. {
  1922.         u32 tmp, buffer_alloc, i;
  1923.         u32 pipe_offset = radeon_crtc->crtc_id * 0x20;
  1924.         /*
  1925.          * Line Buffer Setup
  1926.          * There are 3 line buffers, each one shared by 2 display controllers.
  1927.          * DC_LB_MEMORY_SPLIT controls how that line buffer is shared between
  1928.          * the display controllers.  The paritioning is done via one of four
  1929.          * preset allocations specified in bits 2:0:
  1930.          * first display controller
  1931.          *  0 - first half of lb (3840 * 2)
  1932.          *  1 - first 3/4 of lb (5760 * 2)
  1933.          *  2 - whole lb (7680 * 2), other crtc must be disabled
  1934.          *  3 - first 1/4 of lb (1920 * 2)
  1935.          * second display controller
  1936.          *  4 - second half of lb (3840 * 2)
  1937.          *  5 - second 3/4 of lb (5760 * 2)
  1938.          *  6 - whole lb (7680 * 2), other crtc must be disabled
  1939.          *  7 - last 1/4 of lb (1920 * 2)
  1940.          */
  1941.         /* this can get tricky if we have two large displays on a paired group
  1942.          * of crtcs.  Ideally for multiple large displays we'd assign them to
  1943.          * non-linked crtcs for maximum line buffer allocation.
  1944.          */
  1945.         if (radeon_crtc->base.enabled && mode) {
  1946.                 if (other_mode) {
  1947.                         tmp = 0; /* 1/2 */
  1948.                         buffer_alloc = 1;
  1949.                 } else {
  1950.                         tmp = 2; /* whole */
  1951.                         buffer_alloc = 2;
  1952.                 }
  1953.         } else {
  1954.                 tmp = 0;
  1955.                 buffer_alloc = 0;
  1956.         }
  1957.  
  1958.         /* second controller of the pair uses second half of the lb */
  1959.         if (radeon_crtc->crtc_id % 2)
  1960.                 tmp += 4;
  1961.         WREG32(DC_LB_MEMORY_SPLIT + radeon_crtc->crtc_offset, tmp);
  1962.  
  1963.         if (ASIC_IS_DCE41(rdev) || ASIC_IS_DCE5(rdev)) {
  1964.                 WREG32(PIPE0_DMIF_BUFFER_CONTROL + pipe_offset,
  1965.                        DMIF_BUFFERS_ALLOCATED(buffer_alloc));
  1966.                 for (i = 0; i < rdev->usec_timeout; i++) {
  1967.                         if (RREG32(PIPE0_DMIF_BUFFER_CONTROL + pipe_offset) &
  1968.                             DMIF_BUFFERS_ALLOCATED_COMPLETED)
  1969.                                 break;
  1970.                         udelay(1);
  1971.                 }
  1972.         }
  1973.  
  1974.         if (radeon_crtc->base.enabled && mode) {
  1975.                 switch (tmp) {
  1976.                 case 0:
  1977.                 case 4:
  1978.                 default:
  1979.                         if (ASIC_IS_DCE5(rdev))
  1980.                                 return 4096 * 2;
  1981.                         else
  1982.                                 return 3840 * 2;
  1983.                 case 1:
  1984.                 case 5:
  1985.                         if (ASIC_IS_DCE5(rdev))
  1986.                                 return 6144 * 2;
  1987.                         else
  1988.                                 return 5760 * 2;
  1989.                 case 2:
  1990.                 case 6:
  1991.                         if (ASIC_IS_DCE5(rdev))
  1992.                                 return 8192 * 2;
  1993.                         else
  1994.                                 return 7680 * 2;
  1995.                 case 3:
  1996.                 case 7:
  1997.                         if (ASIC_IS_DCE5(rdev))
  1998.                                 return 2048 * 2;
  1999.                         else
  2000.                                 return 1920 * 2;
  2001.                 }
  2002.         }
  2003.  
  2004.         /* controller not enabled, so no lb used */
  2005.         return 0;
  2006. }
  2007.  
  2008. u32 evergreen_get_number_of_dram_channels(struct radeon_device *rdev)
  2009. {
  2010.         u32 tmp = RREG32(MC_SHARED_CHMAP);
  2011.  
  2012.         switch ((tmp & NOOFCHAN_MASK) >> NOOFCHAN_SHIFT) {
  2013.         case 0:
  2014.         default:
  2015.                 return 1;
  2016.         case 1:
  2017.                 return 2;
  2018.         case 2:
  2019.                 return 4;
  2020.         case 3:
  2021.                 return 8;
  2022.         }
  2023. }
  2024.  
  2025. struct evergreen_wm_params {
  2026.         u32 dram_channels; /* number of dram channels */
  2027.         u32 yclk;          /* bandwidth per dram data pin in kHz */
  2028.         u32 sclk;          /* engine clock in kHz */
  2029.         u32 disp_clk;      /* display clock in kHz */
  2030.         u32 src_width;     /* viewport width */
  2031.         u32 active_time;   /* active display time in ns */
  2032.         u32 blank_time;    /* blank time in ns */
  2033.         bool interlaced;    /* mode is interlaced */
  2034.         fixed20_12 vsc;    /* vertical scale ratio */
  2035.         u32 num_heads;     /* number of active crtcs */
  2036.         u32 bytes_per_pixel; /* bytes per pixel display + overlay */
  2037.         u32 lb_size;       /* line buffer allocated to pipe */
  2038.         u32 vtaps;         /* vertical scaler taps */
  2039. };
  2040.  
  2041. static u32 evergreen_dram_bandwidth(struct evergreen_wm_params *wm)
  2042. {
  2043.         /* Calculate DRAM Bandwidth and the part allocated to display. */
  2044.         fixed20_12 dram_efficiency; /* 0.7 */
  2045.         fixed20_12 yclk, dram_channels, bandwidth;
  2046.         fixed20_12 a;
  2047.  
  2048.         a.full = dfixed_const(1000);
  2049.         yclk.full = dfixed_const(wm->yclk);
  2050.         yclk.full = dfixed_div(yclk, a);
  2051.         dram_channels.full = dfixed_const(wm->dram_channels * 4);
  2052.         a.full = dfixed_const(10);
  2053.         dram_efficiency.full = dfixed_const(7);
  2054.         dram_efficiency.full = dfixed_div(dram_efficiency, a);
  2055.         bandwidth.full = dfixed_mul(dram_channels, yclk);
  2056.         bandwidth.full = dfixed_mul(bandwidth, dram_efficiency);
  2057.  
  2058.         return dfixed_trunc(bandwidth);
  2059. }
  2060.  
  2061. static u32 evergreen_dram_bandwidth_for_display(struct evergreen_wm_params *wm)
  2062. {
  2063.         /* Calculate DRAM Bandwidth and the part allocated to display. */
  2064.         fixed20_12 disp_dram_allocation; /* 0.3 to 0.7 */
  2065.         fixed20_12 yclk, dram_channels, bandwidth;
  2066.         fixed20_12 a;
  2067.  
  2068.         a.full = dfixed_const(1000);
  2069.         yclk.full = dfixed_const(wm->yclk);
  2070.         yclk.full = dfixed_div(yclk, a);
  2071.         dram_channels.full = dfixed_const(wm->dram_channels * 4);
  2072.         a.full = dfixed_const(10);
  2073.         disp_dram_allocation.full = dfixed_const(3); /* XXX worse case value 0.3 */
  2074.         disp_dram_allocation.full = dfixed_div(disp_dram_allocation, a);
  2075.         bandwidth.full = dfixed_mul(dram_channels, yclk);
  2076.         bandwidth.full = dfixed_mul(bandwidth, disp_dram_allocation);
  2077.  
  2078.         return dfixed_trunc(bandwidth);
  2079. }
  2080.  
  2081. static u32 evergreen_data_return_bandwidth(struct evergreen_wm_params *wm)
  2082. {
  2083.         /* Calculate the display Data return Bandwidth */
  2084.         fixed20_12 return_efficiency; /* 0.8 */
  2085.         fixed20_12 sclk, bandwidth;
  2086.         fixed20_12 a;
  2087.  
  2088.         a.full = dfixed_const(1000);
  2089.         sclk.full = dfixed_const(wm->sclk);
  2090.         sclk.full = dfixed_div(sclk, a);
  2091.         a.full = dfixed_const(10);
  2092.         return_efficiency.full = dfixed_const(8);
  2093.         return_efficiency.full = dfixed_div(return_efficiency, a);
  2094.         a.full = dfixed_const(32);
  2095.         bandwidth.full = dfixed_mul(a, sclk);
  2096.         bandwidth.full = dfixed_mul(bandwidth, return_efficiency);
  2097.  
  2098.         return dfixed_trunc(bandwidth);
  2099. }
  2100.  
  2101. static u32 evergreen_dmif_request_bandwidth(struct evergreen_wm_params *wm)
  2102. {
  2103.         /* Calculate the DMIF Request Bandwidth */
  2104.         fixed20_12 disp_clk_request_efficiency; /* 0.8 */
  2105.         fixed20_12 disp_clk, bandwidth;
  2106.         fixed20_12 a;
  2107.  
  2108.         a.full = dfixed_const(1000);
  2109.         disp_clk.full = dfixed_const(wm->disp_clk);
  2110.         disp_clk.full = dfixed_div(disp_clk, a);
  2111.         a.full = dfixed_const(10);
  2112.         disp_clk_request_efficiency.full = dfixed_const(8);
  2113.         disp_clk_request_efficiency.full = dfixed_div(disp_clk_request_efficiency, a);
  2114.         a.full = dfixed_const(32);
  2115.         bandwidth.full = dfixed_mul(a, disp_clk);
  2116.         bandwidth.full = dfixed_mul(bandwidth, disp_clk_request_efficiency);
  2117.  
  2118.         return dfixed_trunc(bandwidth);
  2119. }
  2120.  
  2121. static u32 evergreen_available_bandwidth(struct evergreen_wm_params *wm)
  2122. {
  2123.         /* Calculate the Available bandwidth. Display can use this temporarily but not in average. */
  2124.         u32 dram_bandwidth = evergreen_dram_bandwidth(wm);
  2125.         u32 data_return_bandwidth = evergreen_data_return_bandwidth(wm);
  2126.         u32 dmif_req_bandwidth = evergreen_dmif_request_bandwidth(wm);
  2127.  
  2128.         return min(dram_bandwidth, min(data_return_bandwidth, dmif_req_bandwidth));
  2129. }
  2130.  
  2131. static u32 evergreen_average_bandwidth(struct evergreen_wm_params *wm)
  2132. {
  2133.         /* Calculate the display mode Average Bandwidth
  2134.          * DisplayMode should contain the source and destination dimensions,
  2135.          * timing, etc.
  2136.          */
  2137.         fixed20_12 bpp;
  2138.         fixed20_12 line_time;
  2139.         fixed20_12 src_width;
  2140.         fixed20_12 bandwidth;
  2141.         fixed20_12 a;
  2142.  
  2143.         a.full = dfixed_const(1000);
  2144.         line_time.full = dfixed_const(wm->active_time + wm->blank_time);
  2145.         line_time.full = dfixed_div(line_time, a);
  2146.         bpp.full = dfixed_const(wm->bytes_per_pixel);
  2147.         src_width.full = dfixed_const(wm->src_width);
  2148.         bandwidth.full = dfixed_mul(src_width, bpp);
  2149.         bandwidth.full = dfixed_mul(bandwidth, wm->vsc);
  2150.         bandwidth.full = dfixed_div(bandwidth, line_time);
  2151.  
  2152.         return dfixed_trunc(bandwidth);
  2153. }
  2154.  
  2155. static u32 evergreen_latency_watermark(struct evergreen_wm_params *wm)
  2156. {
  2157.         /* First calcualte the latency in ns */
  2158.         u32 mc_latency = 2000; /* 2000 ns. */
  2159.         u32 available_bandwidth = evergreen_available_bandwidth(wm);
  2160.         u32 worst_chunk_return_time = (512 * 8 * 1000) / available_bandwidth;
  2161.         u32 cursor_line_pair_return_time = (128 * 4 * 1000) / available_bandwidth;
  2162.         u32 dc_latency = 40000000 / wm->disp_clk; /* dc pipe latency */
  2163.         u32 other_heads_data_return_time = ((wm->num_heads + 1) * worst_chunk_return_time) +
  2164.                 (wm->num_heads * cursor_line_pair_return_time);
  2165.         u32 latency = mc_latency + other_heads_data_return_time + dc_latency;
  2166.         u32 max_src_lines_per_dst_line, lb_fill_bw, line_fill_time;
  2167.         fixed20_12 a, b, c;
  2168.  
  2169.         if (wm->num_heads == 0)
  2170.                 return 0;
  2171.  
  2172.         a.full = dfixed_const(2);
  2173.         b.full = dfixed_const(1);
  2174.         if ((wm->vsc.full > a.full) ||
  2175.             ((wm->vsc.full > b.full) && (wm->vtaps >= 3)) ||
  2176.             (wm->vtaps >= 5) ||
  2177.             ((wm->vsc.full >= a.full) && wm->interlaced))
  2178.                 max_src_lines_per_dst_line = 4;
  2179.         else
  2180.                 max_src_lines_per_dst_line = 2;
  2181.  
  2182.         a.full = dfixed_const(available_bandwidth);
  2183.         b.full = dfixed_const(wm->num_heads);
  2184.         a.full = dfixed_div(a, b);
  2185.  
  2186.         b.full = dfixed_const(1000);
  2187.         c.full = dfixed_const(wm->disp_clk);
  2188.         b.full = dfixed_div(c, b);
  2189.         c.full = dfixed_const(wm->bytes_per_pixel);
  2190.         b.full = dfixed_mul(b, c);
  2191.  
  2192.         lb_fill_bw = min(dfixed_trunc(a), dfixed_trunc(b));
  2193.  
  2194.         a.full = dfixed_const(max_src_lines_per_dst_line * wm->src_width * wm->bytes_per_pixel);
  2195.         b.full = dfixed_const(1000);
  2196.         c.full = dfixed_const(lb_fill_bw);
  2197.         b.full = dfixed_div(c, b);
  2198.         a.full = dfixed_div(a, b);
  2199.         line_fill_time = dfixed_trunc(a);
  2200.  
  2201.         if (line_fill_time < wm->active_time)
  2202.                 return latency;
  2203.         else
  2204.                 return latency + (line_fill_time - wm->active_time);
  2205.  
  2206. }
  2207.  
  2208. static bool evergreen_average_bandwidth_vs_dram_bandwidth_for_display(struct evergreen_wm_params *wm)
  2209. {
  2210.         if (evergreen_average_bandwidth(wm) <=
  2211.             (evergreen_dram_bandwidth_for_display(wm) / wm->num_heads))
  2212.                 return true;
  2213.         else
  2214.                 return false;
  2215. };
  2216.  
  2217. static bool evergreen_average_bandwidth_vs_available_bandwidth(struct evergreen_wm_params *wm)
  2218. {
  2219.         if (evergreen_average_bandwidth(wm) <=
  2220.             (evergreen_available_bandwidth(wm) / wm->num_heads))
  2221.                 return true;
  2222.         else
  2223.                 return false;
  2224. };
  2225.  
  2226. static bool evergreen_check_latency_hiding(struct evergreen_wm_params *wm)
  2227. {
  2228.         u32 lb_partitions = wm->lb_size / wm->src_width;
  2229.         u32 line_time = wm->active_time + wm->blank_time;
  2230.         u32 latency_tolerant_lines;
  2231.         u32 latency_hiding;
  2232.         fixed20_12 a;
  2233.  
  2234.         a.full = dfixed_const(1);
  2235.         if (wm->vsc.full > a.full)
  2236.                 latency_tolerant_lines = 1;
  2237.         else {
  2238.                 if (lb_partitions <= (wm->vtaps + 1))
  2239.                         latency_tolerant_lines = 1;
  2240.                 else
  2241.                         latency_tolerant_lines = 2;
  2242.         }
  2243.  
  2244.         latency_hiding = (latency_tolerant_lines * line_time + wm->blank_time);
  2245.  
  2246.         if (evergreen_latency_watermark(wm) <= latency_hiding)
  2247.                 return true;
  2248.         else
  2249.                 return false;
  2250. }
  2251.  
  2252. static void evergreen_program_watermarks(struct radeon_device *rdev,
  2253.                                          struct radeon_crtc *radeon_crtc,
  2254.                                          u32 lb_size, u32 num_heads)
  2255. {
  2256.         struct drm_display_mode *mode = &radeon_crtc->base.mode;
  2257.         struct evergreen_wm_params wm_low, wm_high;
  2258.         u32 dram_channels;
  2259.         u32 pixel_period;
  2260.         u32 line_time = 0;
  2261.         u32 latency_watermark_a = 0, latency_watermark_b = 0;
  2262.         u32 priority_a_mark = 0, priority_b_mark = 0;
  2263.         u32 priority_a_cnt = PRIORITY_OFF;
  2264.         u32 priority_b_cnt = PRIORITY_OFF;
  2265.         u32 pipe_offset = radeon_crtc->crtc_id * 16;
  2266.         u32 tmp, arb_control3;
  2267.         fixed20_12 a, b, c;
  2268.  
  2269.         if (radeon_crtc->base.enabled && num_heads && mode) {
  2270.                 pixel_period = 1000000 / (u32)mode->clock;
  2271.                 line_time = min((u32)mode->crtc_htotal * pixel_period, (u32)65535);
  2272.                 priority_a_cnt = 0;
  2273.                 priority_b_cnt = 0;
  2274.                 dram_channels = evergreen_get_number_of_dram_channels(rdev);
  2275.  
  2276.                 /* watermark for high clocks */
  2277.                 if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) {
  2278.                         wm_high.yclk =
  2279.                                 radeon_dpm_get_mclk(rdev, false) * 10;
  2280.                         wm_high.sclk =
  2281.                                 radeon_dpm_get_sclk(rdev, false) * 10;
  2282.                 } else {
  2283.                         wm_high.yclk = rdev->pm.current_mclk * 10;
  2284.                         wm_high.sclk = rdev->pm.current_sclk * 10;
  2285.                 }
  2286.  
  2287.                 wm_high.disp_clk = mode->clock;
  2288.                 wm_high.src_width = mode->crtc_hdisplay;
  2289.                 wm_high.active_time = mode->crtc_hdisplay * pixel_period;
  2290.                 wm_high.blank_time = line_time - wm_high.active_time;
  2291.                 wm_high.interlaced = false;
  2292.                 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
  2293.                         wm_high.interlaced = true;
  2294.                 wm_high.vsc = radeon_crtc->vsc;
  2295.                 wm_high.vtaps = 1;
  2296.                 if (radeon_crtc->rmx_type != RMX_OFF)
  2297.                         wm_high.vtaps = 2;
  2298.                 wm_high.bytes_per_pixel = 4; /* XXX: get this from fb config */
  2299.                 wm_high.lb_size = lb_size;
  2300.                 wm_high.dram_channels = dram_channels;
  2301.                 wm_high.num_heads = num_heads;
  2302.  
  2303.                 /* watermark for low clocks */
  2304.                 if ((rdev->pm.pm_method == PM_METHOD_DPM) && rdev->pm.dpm_enabled) {
  2305.                         wm_low.yclk =
  2306.                                 radeon_dpm_get_mclk(rdev, true) * 10;
  2307.                         wm_low.sclk =
  2308.                                 radeon_dpm_get_sclk(rdev, true) * 10;
  2309.                 } else {
  2310.                         wm_low.yclk = rdev->pm.current_mclk * 10;
  2311.                         wm_low.sclk = rdev->pm.current_sclk * 10;
  2312.                 }
  2313.  
  2314.                 wm_low.disp_clk = mode->clock;
  2315.                 wm_low.src_width = mode->crtc_hdisplay;
  2316.                 wm_low.active_time = mode->crtc_hdisplay * pixel_period;
  2317.                 wm_low.blank_time = line_time - wm_low.active_time;
  2318.                 wm_low.interlaced = false;
  2319.                 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
  2320.                         wm_low.interlaced = true;
  2321.                 wm_low.vsc = radeon_crtc->vsc;
  2322.                 wm_low.vtaps = 1;
  2323.                 if (radeon_crtc->rmx_type != RMX_OFF)
  2324.                         wm_low.vtaps = 2;
  2325.                 wm_low.bytes_per_pixel = 4; /* XXX: get this from fb config */
  2326.                 wm_low.lb_size = lb_size;
  2327.                 wm_low.dram_channels = dram_channels;
  2328.                 wm_low.num_heads = num_heads;
  2329.  
  2330.                 /* set for high clocks */
  2331.                 latency_watermark_a = min(evergreen_latency_watermark(&wm_high), (u32)65535);
  2332.                 /* set for low clocks */
  2333.                 latency_watermark_b = min(evergreen_latency_watermark(&wm_low), (u32)65535);
  2334.  
  2335.                 /* possibly force display priority to high */
  2336.                 /* should really do this at mode validation time... */
  2337.                 if (!evergreen_average_bandwidth_vs_dram_bandwidth_for_display(&wm_high) ||
  2338.                     !evergreen_average_bandwidth_vs_available_bandwidth(&wm_high) ||
  2339.                     !evergreen_check_latency_hiding(&wm_high) ||
  2340.                     (rdev->disp_priority == 2)) {
  2341.                         DRM_DEBUG_KMS("force priority a to high\n");
  2342.                         priority_a_cnt |= PRIORITY_ALWAYS_ON;
  2343.                 }
  2344.                 if (!evergreen_average_bandwidth_vs_dram_bandwidth_for_display(&wm_low) ||
  2345.                     !evergreen_average_bandwidth_vs_available_bandwidth(&wm_low) ||
  2346.                     !evergreen_check_latency_hiding(&wm_low) ||
  2347.                     (rdev->disp_priority == 2)) {
  2348.                         DRM_DEBUG_KMS("force priority b to high\n");
  2349.                         priority_b_cnt |= PRIORITY_ALWAYS_ON;
  2350.                 }
  2351.  
  2352.                 a.full = dfixed_const(1000);
  2353.                 b.full = dfixed_const(mode->clock);
  2354.                 b.full = dfixed_div(b, a);
  2355.                 c.full = dfixed_const(latency_watermark_a);
  2356.                 c.full = dfixed_mul(c, b);
  2357.                 c.full = dfixed_mul(c, radeon_crtc->hsc);
  2358.                 c.full = dfixed_div(c, a);
  2359.                 a.full = dfixed_const(16);
  2360.                 c.full = dfixed_div(c, a);
  2361.                 priority_a_mark = dfixed_trunc(c);
  2362.                 priority_a_cnt |= priority_a_mark & PRIORITY_MARK_MASK;
  2363.  
  2364.                 a.full = dfixed_const(1000);
  2365.                 b.full = dfixed_const(mode->clock);
  2366.                 b.full = dfixed_div(b, a);
  2367.                 c.full = dfixed_const(latency_watermark_b);
  2368.                 c.full = dfixed_mul(c, b);
  2369.                 c.full = dfixed_mul(c, radeon_crtc->hsc);
  2370.                 c.full = dfixed_div(c, a);
  2371.                 a.full = dfixed_const(16);
  2372.                 c.full = dfixed_div(c, a);
  2373.                 priority_b_mark = dfixed_trunc(c);
  2374.                 priority_b_cnt |= priority_b_mark & PRIORITY_MARK_MASK;
  2375.  
  2376.                 /* Save number of lines the linebuffer leads before the scanout */
  2377.                 radeon_crtc->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);
  2378.         }
  2379.  
  2380.         /* select wm A */
  2381.         arb_control3 = RREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset);
  2382.         tmp = arb_control3;
  2383.         tmp &= ~LATENCY_WATERMARK_MASK(3);
  2384.         tmp |= LATENCY_WATERMARK_MASK(1);
  2385.         WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, tmp);
  2386.         WREG32(PIPE0_LATENCY_CONTROL + pipe_offset,
  2387.                (LATENCY_LOW_WATERMARK(latency_watermark_a) |
  2388.                 LATENCY_HIGH_WATERMARK(line_time)));
  2389.         /* select wm B */
  2390.         tmp = RREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset);
  2391.         tmp &= ~LATENCY_WATERMARK_MASK(3);
  2392.         tmp |= LATENCY_WATERMARK_MASK(2);
  2393.         WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, tmp);
  2394.         WREG32(PIPE0_LATENCY_CONTROL + pipe_offset,
  2395.                (LATENCY_LOW_WATERMARK(latency_watermark_b) |
  2396.                 LATENCY_HIGH_WATERMARK(line_time)));
  2397.         /* restore original selection */
  2398.         WREG32(PIPE0_ARBITRATION_CONTROL3 + pipe_offset, arb_control3);
  2399.  
  2400.         /* write the priority marks */
  2401.         WREG32(PRIORITY_A_CNT + radeon_crtc->crtc_offset, priority_a_cnt);
  2402.         WREG32(PRIORITY_B_CNT + radeon_crtc->crtc_offset, priority_b_cnt);
  2403.  
  2404.         /* save values for DPM */
  2405.         radeon_crtc->line_time = line_time;
  2406.         radeon_crtc->wm_high = latency_watermark_a;
  2407.         radeon_crtc->wm_low = latency_watermark_b;
  2408. }
  2409.  
  2410. /**
  2411.  * evergreen_bandwidth_update - update display watermarks callback.
  2412.  *
  2413.  * @rdev: radeon_device pointer
  2414.  *
  2415.  * Update the display watermarks based on the requested mode(s)
  2416.  * (evergreen+).
  2417.  */
  2418. void evergreen_bandwidth_update(struct radeon_device *rdev)
  2419. {
  2420.         struct drm_display_mode *mode0 = NULL;
  2421.         struct drm_display_mode *mode1 = NULL;
  2422.         u32 num_heads = 0, lb_size;
  2423.         int i;
  2424.  
  2425.         if (!rdev->mode_info.mode_config_initialized)
  2426.                 return;
  2427.  
  2428.         radeon_update_display_priority(rdev);
  2429.  
  2430.         for (i = 0; i < rdev->num_crtc; i++) {
  2431.                 if (rdev->mode_info.crtcs[i]->base.enabled)
  2432.                         num_heads++;
  2433.         }
  2434.         for (i = 0; i < rdev->num_crtc; i += 2) {
  2435.                 mode0 = &rdev->mode_info.crtcs[i]->base.mode;
  2436.                 mode1 = &rdev->mode_info.crtcs[i+1]->base.mode;
  2437.                 lb_size = evergreen_line_buffer_adjust(rdev, rdev->mode_info.crtcs[i], mode0, mode1);
  2438.                 evergreen_program_watermarks(rdev, rdev->mode_info.crtcs[i], lb_size, num_heads);
  2439.                 lb_size = evergreen_line_buffer_adjust(rdev, rdev->mode_info.crtcs[i+1], mode1, mode0);
  2440.                 evergreen_program_watermarks(rdev, rdev->mode_info.crtcs[i+1], lb_size, num_heads);
  2441.         }
  2442. }
  2443.  
  2444. /**
  2445.  * evergreen_mc_wait_for_idle - wait for MC idle callback.
  2446.  *
  2447.  * @rdev: radeon_device pointer
  2448.  *
  2449.  * Wait for the MC (memory controller) to be idle.
  2450.  * (evergreen+).
  2451.  * Returns 0 if the MC is idle, -1 if not.
  2452.  */
  2453. int evergreen_mc_wait_for_idle(struct radeon_device *rdev)
  2454. {
  2455.         unsigned i;
  2456.         u32 tmp;
  2457.  
  2458.         for (i = 0; i < rdev->usec_timeout; i++) {
  2459.                 /* read MC_STATUS */
  2460.                 tmp = RREG32(SRBM_STATUS) & 0x1F00;
  2461.                 if (!tmp)
  2462.                         return 0;
  2463.                 udelay(1);
  2464.         }
  2465.         return -1;
  2466. }
  2467.  
  2468. /*
  2469.  * GART
  2470.  */
  2471. void evergreen_pcie_gart_tlb_flush(struct radeon_device *rdev)
  2472. {
  2473.         unsigned i;
  2474.         u32 tmp;
  2475.  
  2476.         WREG32(HDP_MEM_COHERENCY_FLUSH_CNTL, 0x1);
  2477.  
  2478.         WREG32(VM_CONTEXT0_REQUEST_RESPONSE, REQUEST_TYPE(1));
  2479.         for (i = 0; i < rdev->usec_timeout; i++) {
  2480.                 /* read MC_STATUS */
  2481.                 tmp = RREG32(VM_CONTEXT0_REQUEST_RESPONSE);
  2482.                 tmp = (tmp & RESPONSE_TYPE_MASK) >> RESPONSE_TYPE_SHIFT;
  2483.                 if (tmp == 2) {
  2484.                         printk(KERN_WARNING "[drm] r600 flush TLB failed\n");
  2485.                         return;
  2486.                 }
  2487.                 if (tmp) {
  2488.                         return;
  2489.                 }
  2490.                 udelay(1);
  2491.         }
  2492. }
  2493.  
  2494. static int evergreen_pcie_gart_enable(struct radeon_device *rdev)
  2495. {
  2496.         u32 tmp;
  2497.         int r;
  2498.  
  2499.         if (rdev->gart.robj == NULL) {
  2500.                 dev_err(rdev->dev, "No VRAM object for PCIE GART.\n");
  2501.                 return -EINVAL;
  2502.         }
  2503.         r = radeon_gart_table_vram_pin(rdev);
  2504.         if (r)
  2505.                 return r;
  2506.         /* Setup L2 cache */
  2507.         WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING |
  2508.                                 ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE |
  2509.                                 EFFECTIVE_L2_QUEUE_SIZE(7));
  2510.         WREG32(VM_L2_CNTL2, 0);
  2511.         WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
  2512.         /* Setup TLB control */
  2513.         tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING |
  2514.                 SYSTEM_ACCESS_MODE_NOT_IN_SYS |
  2515.                 SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU |
  2516.                 EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
  2517.         if (rdev->flags & RADEON_IS_IGP) {
  2518.                 WREG32(FUS_MC_VM_MD_L1_TLB0_CNTL, tmp);
  2519.                 WREG32(FUS_MC_VM_MD_L1_TLB1_CNTL, tmp);
  2520.                 WREG32(FUS_MC_VM_MD_L1_TLB2_CNTL, tmp);
  2521.         } else {
  2522.                 WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
  2523.                 WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
  2524.                 WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
  2525.                 if ((rdev->family == CHIP_JUNIPER) ||
  2526.                     (rdev->family == CHIP_CYPRESS) ||
  2527.                     (rdev->family == CHIP_HEMLOCK) ||
  2528.                     (rdev->family == CHIP_BARTS))
  2529.                         WREG32(MC_VM_MD_L1_TLB3_CNTL, tmp);
  2530.         }
  2531.         WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
  2532.         WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
  2533.         WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
  2534.         WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
  2535.         WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12);
  2536.         WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, rdev->mc.gtt_end >> 12);
  2537.         WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12);
  2538.         WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) |
  2539.                                 RANGE_PROTECTION_FAULT_ENABLE_DEFAULT);
  2540.         WREG32(VM_CONTEXT0_PROTECTION_FAULT_DEFAULT_ADDR,
  2541.                         (u32)(rdev->dummy_page.addr >> 12));
  2542.         WREG32(VM_CONTEXT1_CNTL, 0);
  2543.  
  2544.         evergreen_pcie_gart_tlb_flush(rdev);
  2545.         DRM_INFO("PCIE GART of %uM enabled (table at 0x%016llX).\n",
  2546.                  (unsigned)(rdev->mc.gtt_size >> 20),
  2547.                  (unsigned long long)rdev->gart.table_addr);
  2548.         rdev->gart.ready = true;
  2549.         return 0;
  2550. }
  2551.  
  2552. static void evergreen_pcie_gart_disable(struct radeon_device *rdev)
  2553. {
  2554.         u32 tmp;
  2555.  
  2556.         /* Disable all tables */
  2557.         WREG32(VM_CONTEXT0_CNTL, 0);
  2558.         WREG32(VM_CONTEXT1_CNTL, 0);
  2559.  
  2560.         /* Setup L2 cache */
  2561.         WREG32(VM_L2_CNTL, ENABLE_L2_FRAGMENT_PROCESSING |
  2562.                                 EFFECTIVE_L2_QUEUE_SIZE(7));
  2563.         WREG32(VM_L2_CNTL2, 0);
  2564.         WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
  2565.         /* Setup TLB control */
  2566.         tmp = EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
  2567.         WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp);
  2568.         WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp);
  2569.         WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp);
  2570.         WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp);
  2571.         WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp);
  2572.         WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp);
  2573.         WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp);
  2574.         radeon_gart_table_vram_unpin(rdev);
  2575. }
  2576.  
  2577. static void evergreen_pcie_gart_fini(struct radeon_device *rdev)
  2578. {
  2579.         evergreen_pcie_gart_disable(rdev);
  2580.         radeon_gart_table_vram_free(rdev);
  2581.         radeon_gart_fini(rdev);
  2582. }