Subversion Repositories Kolibri OS

Rev

Rev 5060 | Rev 5139 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright © 2008 Intel Corporation
  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 (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21.  * IN THE SOFTWARE.
  22.  *
  23.  * Authors:
  24.  *    Keith Packard <keithp@keithp.com>
  25.  *
  26.  */
  27.  
  28. #include <linux/i2c.h>
  29. #include <linux/slab.h>
  30. #include <linux/export.h>
  31. #include <drm/drmP.h>
  32. #include <drm/drm_crtc.h>
  33. #include <drm/drm_crtc_helper.h>
  34. #include <drm/drm_edid.h>
  35. #include "intel_drv.h"
  36. #include <drm/i915_drm.h>
  37. #include "i915_drv.h"
  38.  
  39. #define DP_LINK_CHECK_TIMEOUT   (10 * 1000)
  40.  
  41. struct dp_link_dpll {
  42.         int link_bw;
  43.         struct dpll dpll;
  44. };
  45.  
  46. static const struct dp_link_dpll gen4_dpll[] = {
  47.         { DP_LINK_BW_1_62,
  48.                 { .p1 = 2, .p2 = 10, .n = 2, .m1 = 23, .m2 = 8 } },
  49.         { DP_LINK_BW_2_7,
  50.                 { .p1 = 1, .p2 = 10, .n = 1, .m1 = 14, .m2 = 2 } }
  51. };
  52.  
  53. static const struct dp_link_dpll pch_dpll[] = {
  54.         { DP_LINK_BW_1_62,
  55.                 { .p1 = 2, .p2 = 10, .n = 1, .m1 = 12, .m2 = 9 } },
  56.         { DP_LINK_BW_2_7,
  57.                 { .p1 = 1, .p2 = 10, .n = 2, .m1 = 14, .m2 = 8 } }
  58. };
  59.  
  60. static const struct dp_link_dpll vlv_dpll[] = {
  61.         { DP_LINK_BW_1_62,
  62.                 { .p1 = 3, .p2 = 2, .n = 5, .m1 = 3, .m2 = 81 } },
  63.         { DP_LINK_BW_2_7,
  64.                 { .p1 = 2, .p2 = 2, .n = 1, .m1 = 2, .m2 = 27 } }
  65. };
  66.  
  67. /*
  68.  * CHV supports eDP 1.4 that have  more link rates.
  69.  * Below only provides the fixed rate but exclude variable rate.
  70.  */
  71. static const struct dp_link_dpll chv_dpll[] = {
  72.         /*
  73.          * CHV requires to program fractional division for m2.
  74.          * m2 is stored in fixed point format using formula below
  75.          * (m2_int << 22) | m2_fraction
  76.          */
  77.         { DP_LINK_BW_1_62,      /* m2_int = 32, m2_fraction = 1677722 */
  78.                 { .p1 = 4, .p2 = 2, .n = 1, .m1 = 2, .m2 = 0x819999a } },
  79.         { DP_LINK_BW_2_7,       /* m2_int = 27, m2_fraction = 0 */
  80.                 { .p1 = 4, .p2 = 1, .n = 1, .m1 = 2, .m2 = 0x6c00000 } },
  81.         { DP_LINK_BW_5_4,       /* m2_int = 27, m2_fraction = 0 */
  82.                 { .p1 = 2, .p2 = 1, .n = 1, .m1 = 2, .m2 = 0x6c00000 } }
  83. };
  84.  
  85. /**
  86.  * is_edp - is the given port attached to an eDP panel (either CPU or PCH)
  87.  * @intel_dp: DP struct
  88.  *
  89.  * If a CPU or PCH DP output is attached to an eDP panel, this function
  90.  * will return true, and false otherwise.
  91.  */
  92. static bool is_edp(struct intel_dp *intel_dp)
  93. {
  94.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  95.  
  96.         return intel_dig_port->base.type == INTEL_OUTPUT_EDP;
  97. }
  98.  
  99. static struct drm_device *intel_dp_to_dev(struct intel_dp *intel_dp)
  100. {
  101.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  102.  
  103.         return intel_dig_port->base.base.dev;
  104. }
  105.  
  106. static struct intel_dp *intel_attached_dp(struct drm_connector *connector)
  107. {
  108.         return enc_to_intel_dp(&intel_attached_encoder(connector)->base);
  109. }
  110.  
  111. static void intel_dp_link_down(struct intel_dp *intel_dp);
  112. static bool _edp_panel_vdd_on(struct intel_dp *intel_dp);
  113. static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync);
  114.  
  115. int
  116. intel_dp_max_link_bw(struct intel_dp *intel_dp)
  117. {
  118.         int max_link_bw = intel_dp->dpcd[DP_MAX_LINK_RATE];
  119.         struct drm_device *dev = intel_dp->attached_connector->base.dev;
  120.  
  121.         switch (max_link_bw) {
  122.         case DP_LINK_BW_1_62:
  123.         case DP_LINK_BW_2_7:
  124.                 break;
  125.         case DP_LINK_BW_5_4: /* 1.2 capable displays may advertise higher bw */
  126.                 if (((IS_HASWELL(dev) && !IS_HSW_ULX(dev)) ||
  127.                      INTEL_INFO(dev)->gen >= 8) &&
  128.                     intel_dp->dpcd[DP_DPCD_REV] >= 0x12)
  129.                         max_link_bw = DP_LINK_BW_5_4;
  130.                 else
  131.                         max_link_bw = DP_LINK_BW_2_7;
  132.                 break;
  133.         default:
  134.                 WARN(1, "invalid max DP link bw val %x, using 1.62Gbps\n",
  135.                      max_link_bw);
  136.                 max_link_bw = DP_LINK_BW_1_62;
  137.                 break;
  138.         }
  139.         return max_link_bw;
  140. }
  141.  
  142. static u8 intel_dp_max_lane_count(struct intel_dp *intel_dp)
  143. {
  144.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  145.         struct drm_device *dev = intel_dig_port->base.base.dev;
  146.         u8 source_max, sink_max;
  147.  
  148.         source_max = 4;
  149.         if (HAS_DDI(dev) && intel_dig_port->port == PORT_A &&
  150.             (intel_dig_port->saved_port_bits & DDI_A_4_LANES) == 0)
  151.                 source_max = 2;
  152.  
  153.         sink_max = drm_dp_max_lane_count(intel_dp->dpcd);
  154.  
  155.         return min(source_max, sink_max);
  156. }
  157.  
  158. /*
  159.  * The units on the numbers in the next two are... bizarre.  Examples will
  160.  * make it clearer; this one parallels an example in the eDP spec.
  161.  *
  162.  * intel_dp_max_data_rate for one lane of 2.7GHz evaluates as:
  163.  *
  164.  *     270000 * 1 * 8 / 10 == 216000
  165.  *
  166.  * The actual data capacity of that configuration is 2.16Gbit/s, so the
  167.  * units are decakilobits.  ->clock in a drm_display_mode is in kilohertz -
  168.  * or equivalently, kilopixels per second - so for 1680x1050R it'd be
  169.  * 119000.  At 18bpp that's 2142000 kilobits per second.
  170.  *
  171.  * Thus the strange-looking division by 10 in intel_dp_link_required, to
  172.  * get the result in decakilobits instead of kilobits.
  173.  */
  174.  
  175. static int
  176. intel_dp_link_required(int pixel_clock, int bpp)
  177. {
  178.         return (pixel_clock * bpp + 9) / 10;
  179. }
  180.  
  181. static int
  182. intel_dp_max_data_rate(int max_link_clock, int max_lanes)
  183. {
  184.         return (max_link_clock * max_lanes * 8) / 10;
  185. }
  186.  
  187. static enum drm_mode_status
  188. intel_dp_mode_valid(struct drm_connector *connector,
  189.                     struct drm_display_mode *mode)
  190. {
  191.         struct intel_dp *intel_dp = intel_attached_dp(connector);
  192.         struct intel_connector *intel_connector = to_intel_connector(connector);
  193.         struct drm_display_mode *fixed_mode = intel_connector->panel.fixed_mode;
  194.         int target_clock = mode->clock;
  195.         int max_rate, mode_rate, max_lanes, max_link_clock;
  196.  
  197.         if (is_edp(intel_dp) && fixed_mode) {
  198.                 if (mode->hdisplay > fixed_mode->hdisplay)
  199.                         return MODE_PANEL;
  200.  
  201.                 if (mode->vdisplay > fixed_mode->vdisplay)
  202.                         return MODE_PANEL;
  203.  
  204.                 target_clock = fixed_mode->clock;
  205.         }
  206.  
  207.         max_link_clock = drm_dp_bw_code_to_link_rate(intel_dp_max_link_bw(intel_dp));
  208.         max_lanes = intel_dp_max_lane_count(intel_dp);
  209.  
  210.         max_rate = intel_dp_max_data_rate(max_link_clock, max_lanes);
  211.         mode_rate = intel_dp_link_required(target_clock, 18);
  212.  
  213.         if (mode_rate > max_rate)
  214.                 return MODE_CLOCK_HIGH;
  215.  
  216.         if (mode->clock < 10000)
  217.                 return MODE_CLOCK_LOW;
  218.  
  219.         if (mode->flags & DRM_MODE_FLAG_DBLCLK)
  220.                 return MODE_H_ILLEGAL;
  221.  
  222.         return MODE_OK;
  223. }
  224.  
  225. static uint32_t
  226. pack_aux(uint8_t *src, int src_bytes)
  227. {
  228.         int     i;
  229.         uint32_t v = 0;
  230.  
  231.         if (src_bytes > 4)
  232.                 src_bytes = 4;
  233.         for (i = 0; i < src_bytes; i++)
  234.                 v |= ((uint32_t) src[i]) << ((3-i) * 8);
  235.         return v;
  236. }
  237.  
  238. static void
  239. unpack_aux(uint32_t src, uint8_t *dst, int dst_bytes)
  240. {
  241.         int i;
  242.         if (dst_bytes > 4)
  243.                 dst_bytes = 4;
  244.         for (i = 0; i < dst_bytes; i++)
  245.                 dst[i] = src >> ((3-i) * 8);
  246. }
  247.  
  248. /* hrawclock is 1/4 the FSB frequency */
  249. static int
  250. intel_hrawclk(struct drm_device *dev)
  251. {
  252.         struct drm_i915_private *dev_priv = dev->dev_private;
  253.         uint32_t clkcfg;
  254.  
  255.         /* There is no CLKCFG reg in Valleyview. VLV hrawclk is 200 MHz */
  256.         if (IS_VALLEYVIEW(dev))
  257.                 return 200;
  258.  
  259.         clkcfg = I915_READ(CLKCFG);
  260.         switch (clkcfg & CLKCFG_FSB_MASK) {
  261.         case CLKCFG_FSB_400:
  262.                 return 100;
  263.         case CLKCFG_FSB_533:
  264.                 return 133;
  265.         case CLKCFG_FSB_667:
  266.                 return 166;
  267.         case CLKCFG_FSB_800:
  268.                 return 200;
  269.         case CLKCFG_FSB_1067:
  270.                 return 266;
  271.         case CLKCFG_FSB_1333:
  272.                 return 333;
  273.         /* these two are just a guess; one of them might be right */
  274.         case CLKCFG_FSB_1600:
  275.         case CLKCFG_FSB_1600_ALT:
  276.                 return 400;
  277.         default:
  278.                 return 133;
  279.         }
  280. }
  281.  
  282. static void
  283. intel_dp_init_panel_power_sequencer(struct drm_device *dev,
  284.                                     struct intel_dp *intel_dp,
  285.                                     struct edp_power_seq *out);
  286. static void
  287. intel_dp_init_panel_power_sequencer_registers(struct drm_device *dev,
  288.                                               struct intel_dp *intel_dp,
  289.                                               struct edp_power_seq *out);
  290.  
  291. static enum pipe
  292. vlv_power_sequencer_pipe(struct intel_dp *intel_dp)
  293. {
  294.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  295.         struct drm_crtc *crtc = intel_dig_port->base.base.crtc;
  296.         struct drm_device *dev = intel_dig_port->base.base.dev;
  297.         struct drm_i915_private *dev_priv = dev->dev_private;
  298.         enum port port = intel_dig_port->port;
  299.         enum pipe pipe;
  300.  
  301.         /* modeset should have pipe */
  302.         if (crtc)
  303.                 return to_intel_crtc(crtc)->pipe;
  304.  
  305.         /* init time, try to find a pipe with this port selected */
  306.         for (pipe = PIPE_A; pipe <= PIPE_B; pipe++) {
  307.                 u32 port_sel = I915_READ(VLV_PIPE_PP_ON_DELAYS(pipe)) &
  308.                         PANEL_PORT_SELECT_MASK;
  309.                 if (port_sel == PANEL_PORT_SELECT_DPB_VLV && port == PORT_B)
  310.                         return pipe;
  311.                 if (port_sel == PANEL_PORT_SELECT_DPC_VLV && port == PORT_C)
  312.                         return pipe;
  313.         }
  314.  
  315.         /* shrug */
  316.         return PIPE_A;
  317. }
  318.  
  319. static u32 _pp_ctrl_reg(struct intel_dp *intel_dp)
  320. {
  321.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  322.  
  323.         if (HAS_PCH_SPLIT(dev))
  324.                 return PCH_PP_CONTROL;
  325.         else
  326.                 return VLV_PIPE_PP_CONTROL(vlv_power_sequencer_pipe(intel_dp));
  327. }
  328.  
  329. static u32 _pp_stat_reg(struct intel_dp *intel_dp)
  330. {
  331.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  332.  
  333.         if (HAS_PCH_SPLIT(dev))
  334.                 return PCH_PP_STATUS;
  335.         else
  336.                 return VLV_PIPE_PP_STATUS(vlv_power_sequencer_pipe(intel_dp));
  337. }
  338.  
  339.  
  340. static bool edp_have_panel_power(struct intel_dp *intel_dp)
  341. {
  342.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  343.         struct drm_i915_private *dev_priv = dev->dev_private;
  344.  
  345.         return (I915_READ(_pp_stat_reg(intel_dp)) & PP_ON) != 0;
  346. }
  347.  
  348. static bool edp_have_panel_vdd(struct intel_dp *intel_dp)
  349. {
  350.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  351.         struct drm_i915_private *dev_priv = dev->dev_private;
  352.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  353.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  354.         enum intel_display_power_domain power_domain;
  355.  
  356.         power_domain = intel_display_port_power_domain(intel_encoder);
  357.         return intel_display_power_enabled(dev_priv, power_domain) &&
  358.                (I915_READ(_pp_ctrl_reg(intel_dp)) & EDP_FORCE_VDD) != 0;
  359. }
  360.  
  361. static void
  362. intel_dp_check_edp(struct intel_dp *intel_dp)
  363. {
  364.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  365.         struct drm_i915_private *dev_priv = dev->dev_private;
  366.  
  367.         if (!is_edp(intel_dp))
  368.                 return;
  369.  
  370.         if (!edp_have_panel_power(intel_dp) && !edp_have_panel_vdd(intel_dp)) {
  371.                 WARN(1, "eDP powered off while attempting aux channel communication.\n");
  372.                 DRM_DEBUG_KMS("Status 0x%08x Control 0x%08x\n",
  373.                               I915_READ(_pp_stat_reg(intel_dp)),
  374.                               I915_READ(_pp_ctrl_reg(intel_dp)));
  375.         }
  376. }
  377.  
  378. static uint32_t
  379. intel_dp_aux_wait_done(struct intel_dp *intel_dp, bool has_aux_irq)
  380. {
  381.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  382.         struct drm_device *dev = intel_dig_port->base.base.dev;
  383.         struct drm_i915_private *dev_priv = dev->dev_private;
  384.         uint32_t ch_ctl = intel_dp->aux_ch_ctl_reg;
  385.         uint32_t status;
  386.         bool done;
  387.  
  388. #define C (((status = I915_READ_NOTRACE(ch_ctl)) & DP_AUX_CH_CTL_SEND_BUSY) == 0)
  389.         if (has_aux_irq)
  390.                 done = wait_event_timeout(dev_priv->gmbus_wait_queue, C,
  391.                                           msecs_to_jiffies_timeout(10));
  392.         else
  393.                 done = wait_for_atomic(C, 10) == 0;
  394.         if (!done)
  395.                 DRM_ERROR("dp aux hw did not signal timeout (has irq: %i)!\n",
  396.                           has_aux_irq);
  397. #undef C
  398.  
  399.         return status;
  400. }
  401.  
  402. static uint32_t i9xx_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
  403. {
  404.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  405.         struct drm_device *dev = intel_dig_port->base.base.dev;
  406.  
  407.         /*
  408.          * The clock divider is based off the hrawclk, and would like to run at
  409.          * 2MHz.  So, take the hrawclk value and divide by 2 and use that
  410.          */
  411.         return index ? 0 : intel_hrawclk(dev) / 2;
  412. }
  413.  
  414. static uint32_t ilk_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
  415. {
  416.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  417.         struct drm_device *dev = intel_dig_port->base.base.dev;
  418.  
  419.         if (index)
  420.                 return 0;
  421.  
  422.         if (intel_dig_port->port == PORT_A) {
  423.                 if (IS_GEN6(dev) || IS_GEN7(dev))
  424.                         return 200; /* SNB & IVB eDP input clock at 400Mhz */
  425.                 else
  426.                         return 225; /* eDP input clock at 450Mhz */
  427.         } else {
  428.                 return DIV_ROUND_UP(intel_pch_rawclk(dev), 2);
  429.         }
  430. }
  431.  
  432. static uint32_t hsw_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
  433. {
  434.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  435.         struct drm_device *dev = intel_dig_port->base.base.dev;
  436.         struct drm_i915_private *dev_priv = dev->dev_private;
  437.  
  438.         if (intel_dig_port->port == PORT_A) {
  439.                 if (index)
  440.                         return 0;
  441.                 return DIV_ROUND_CLOSEST(intel_ddi_get_cdclk_freq(dev_priv), 2000);
  442.         } else if (dev_priv->pch_id == INTEL_PCH_LPT_DEVICE_ID_TYPE) {
  443.                 /* Workaround for non-ULT HSW */
  444.                 switch (index) {
  445.                 case 0: return 63;
  446.                 case 1: return 72;
  447.                 default: return 0;
  448.                 }
  449.         } else  {
  450.                 return index ? 0 : DIV_ROUND_UP(intel_pch_rawclk(dev), 2);
  451.         }
  452. }
  453.  
  454. static uint32_t vlv_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
  455. {
  456.         return index ? 0 : 100;
  457. }
  458.  
  459. static uint32_t i9xx_get_aux_send_ctl(struct intel_dp *intel_dp,
  460.                                       bool has_aux_irq,
  461.                                       int send_bytes,
  462.                                       uint32_t aux_clock_divider)
  463. {
  464.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  465.         struct drm_device *dev = intel_dig_port->base.base.dev;
  466.         uint32_t precharge, timeout;
  467.  
  468.         if (IS_GEN6(dev))
  469.                 precharge = 3;
  470.         else
  471.                 precharge = 5;
  472.  
  473.         if (IS_BROADWELL(dev) && intel_dp->aux_ch_ctl_reg == DPA_AUX_CH_CTL)
  474.                 timeout = DP_AUX_CH_CTL_TIME_OUT_600us;
  475.         else
  476.                 timeout = DP_AUX_CH_CTL_TIME_OUT_400us;
  477.  
  478.         return DP_AUX_CH_CTL_SEND_BUSY |
  479.                DP_AUX_CH_CTL_DONE |
  480.                (has_aux_irq ? DP_AUX_CH_CTL_INTERRUPT : 0) |
  481.                DP_AUX_CH_CTL_TIME_OUT_ERROR |
  482.                timeout |
  483.                DP_AUX_CH_CTL_RECEIVE_ERROR |
  484.                (send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
  485.                (precharge << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
  486.                (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT);
  487. }
  488.  
  489. static int
  490. intel_dp_aux_ch(struct intel_dp *intel_dp,
  491.                 uint8_t *send, int send_bytes,
  492.                 uint8_t *recv, int recv_size)
  493. {
  494.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  495.         struct drm_device *dev = intel_dig_port->base.base.dev;
  496.         struct drm_i915_private *dev_priv = dev->dev_private;
  497.         uint32_t ch_ctl = intel_dp->aux_ch_ctl_reg;
  498.         uint32_t ch_data = ch_ctl + 4;
  499.         uint32_t aux_clock_divider;
  500.         int i, ret, recv_bytes;
  501.         uint32_t status;
  502.         int try, clock = 0;
  503.         bool has_aux_irq = HAS_AUX_IRQ(dev);
  504.         bool vdd;
  505.  
  506.         vdd = _edp_panel_vdd_on(intel_dp);
  507.  
  508.         /* dp aux is extremely sensitive to irq latency, hence request the
  509.          * lowest possible wakeup latency and so prevent the cpu from going into
  510.          * deep sleep states.
  511.          */
  512.  
  513.         intel_dp_check_edp(intel_dp);
  514.  
  515.         intel_aux_display_runtime_get(dev_priv);
  516.  
  517.         /* Try to wait for any previous AUX channel activity */
  518.         for (try = 0; try < 3; try++) {
  519.                 status = I915_READ_NOTRACE(ch_ctl);
  520.                 if ((status & DP_AUX_CH_CTL_SEND_BUSY) == 0)
  521.                         break;
  522.                 msleep(1);
  523.         }
  524.  
  525.         if (try == 3) {
  526.                 WARN(1, "dp_aux_ch not started status 0x%08x\n",
  527.                      I915_READ(ch_ctl));
  528.                 ret = -EBUSY;
  529.                 goto out;
  530.         }
  531.  
  532.         /* Only 5 data registers! */
  533.         if (WARN_ON(send_bytes > 20 || recv_size > 20)) {
  534.                 ret = -E2BIG;
  535.                 goto out;
  536.         }
  537.  
  538.         while ((aux_clock_divider = intel_dp->get_aux_clock_divider(intel_dp, clock++))) {
  539.                 u32 send_ctl = intel_dp->get_aux_send_ctl(intel_dp,
  540.                                                           has_aux_irq,
  541.                                                           send_bytes,
  542.                                                           aux_clock_divider);
  543.  
  544.         /* Must try at least 3 times according to DP spec */
  545.         for (try = 0; try < 5; try++) {
  546.                 /* Load the send data into the aux channel data registers */
  547.                 for (i = 0; i < send_bytes; i += 4)
  548.                         I915_WRITE(ch_data + i,
  549.                                    pack_aux(send + i, send_bytes - i));
  550.  
  551.                 /* Send the command and wait for it to complete */
  552.                         I915_WRITE(ch_ctl, send_ctl);
  553.  
  554.                 status = intel_dp_aux_wait_done(intel_dp, has_aux_irq);
  555.  
  556.                 /* Clear done status and any errors */
  557.                 I915_WRITE(ch_ctl,
  558.                            status |
  559.                            DP_AUX_CH_CTL_DONE |
  560.                            DP_AUX_CH_CTL_TIME_OUT_ERROR |
  561.                            DP_AUX_CH_CTL_RECEIVE_ERROR);
  562.  
  563.                 if (status & (DP_AUX_CH_CTL_TIME_OUT_ERROR |
  564.                               DP_AUX_CH_CTL_RECEIVE_ERROR))
  565.                         continue;
  566.                 if (status & DP_AUX_CH_CTL_DONE)
  567.                         break;
  568.         }
  569.                 if (status & DP_AUX_CH_CTL_DONE)
  570.                         break;
  571.         }
  572.  
  573.         if ((status & DP_AUX_CH_CTL_DONE) == 0) {
  574.                 DRM_ERROR("dp_aux_ch not done status 0x%08x\n", status);
  575.                 ret = -EBUSY;
  576.                 goto out;
  577.         }
  578.  
  579.         /* Check for timeout or receive error.
  580.          * Timeouts occur when the sink is not connected
  581.          */
  582.         if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) {
  583.                 DRM_ERROR("dp_aux_ch receive error status 0x%08x\n", status);
  584.                 ret = -EIO;
  585.                 goto out;
  586.         }
  587.  
  588.         /* Timeouts occur when the device isn't connected, so they're
  589.          * "normal" -- don't fill the kernel log with these */
  590.         if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) {
  591.                 DRM_DEBUG_KMS("dp_aux_ch timeout status 0x%08x\n", status);
  592.                 ret = -ETIMEDOUT;
  593.                 goto out;
  594.         }
  595.  
  596.         /* Unload any bytes sent back from the other side */
  597.         recv_bytes = ((status & DP_AUX_CH_CTL_MESSAGE_SIZE_MASK) >>
  598.                       DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT);
  599.         if (recv_bytes > recv_size)
  600.                 recv_bytes = recv_size;
  601.  
  602.         for (i = 0; i < recv_bytes; i += 4)
  603.                 unpack_aux(I915_READ(ch_data + i),
  604.                            recv + i, recv_bytes - i);
  605.  
  606.         ret = recv_bytes;
  607. out:
  608. //      pm_qos_update_request(&dev_priv->pm_qos, PM_QOS_DEFAULT_VALUE);
  609.         intel_aux_display_runtime_put(dev_priv);
  610.  
  611.         if (vdd)
  612.                 edp_panel_vdd_off(intel_dp, false);
  613.  
  614.         return ret;
  615. }
  616.  
  617. #define BARE_ADDRESS_SIZE       3
  618. #define HEADER_SIZE             (BARE_ADDRESS_SIZE + 1)
  619. static ssize_t
  620. intel_dp_aux_transfer(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
  621. {
  622.         struct intel_dp *intel_dp = container_of(aux, struct intel_dp, aux);
  623.         uint8_t txbuf[20], rxbuf[20];
  624.         size_t txsize, rxsize;
  625.         int ret;
  626.  
  627.         txbuf[0] = msg->request << 4;
  628.         txbuf[1] = msg->address >> 8;
  629.         txbuf[2] = msg->address & 0xff;
  630.         txbuf[3] = msg->size - 1;
  631.  
  632.         switch (msg->request & ~DP_AUX_I2C_MOT) {
  633.         case DP_AUX_NATIVE_WRITE:
  634.         case DP_AUX_I2C_WRITE:
  635.                 txsize = msg->size ? HEADER_SIZE + msg->size : BARE_ADDRESS_SIZE;
  636.                 rxsize = 1;
  637.  
  638.                 if (WARN_ON(txsize > 20))
  639.                 return -E2BIG;
  640.  
  641.                 memcpy(txbuf + HEADER_SIZE, msg->buffer, msg->size);
  642.  
  643.                 ret = intel_dp_aux_ch(intel_dp, txbuf, txsize, rxbuf, rxsize);
  644.                 if (ret > 0) {
  645.                         msg->reply = rxbuf[0] >> 4;
  646.  
  647.                         /* Return payload size. */
  648.                         ret = msg->size;
  649.                 }
  650.                         break;
  651.  
  652.         case DP_AUX_NATIVE_READ:
  653.         case DP_AUX_I2C_READ:
  654.                 txsize = msg->size ? HEADER_SIZE : BARE_ADDRESS_SIZE;
  655.                 rxsize = msg->size + 1;
  656.  
  657.                 if (WARN_ON(rxsize > 20))
  658.                 return -E2BIG;
  659.  
  660.                 ret = intel_dp_aux_ch(intel_dp, txbuf, txsize, rxbuf, rxsize);
  661.                 if (ret > 0) {
  662.                         msg->reply = rxbuf[0] >> 4;
  663.                         /*
  664.                          * Assume happy day, and copy the data. The caller is
  665.                          * expected to check msg->reply before touching it.
  666.                          *
  667.                          * Return payload size.
  668.                          */
  669.                         ret--;
  670.                         memcpy(msg->buffer, rxbuf + 1, ret);
  671.                 }
  672.                 break;
  673.  
  674.         default:
  675.                 ret = -EINVAL;
  676.                 break;
  677.         }
  678.  
  679.                         return ret;
  680. }
  681.  
  682. static void
  683. intel_dp_aux_init(struct intel_dp *intel_dp, struct intel_connector *connector)
  684. {
  685.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  686.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  687.         enum port port = intel_dig_port->port;
  688.         const char *name = NULL;
  689.         int ret;
  690.  
  691.         switch (port) {
  692.         case PORT_A:
  693.                 intel_dp->aux_ch_ctl_reg = DPA_AUX_CH_CTL;
  694.                 name = "DPDDC-A";
  695.                 break;
  696.         case PORT_B:
  697.                 intel_dp->aux_ch_ctl_reg = PCH_DPB_AUX_CH_CTL;
  698.                 name = "DPDDC-B";
  699.                 break;
  700.         case PORT_C:
  701.                 intel_dp->aux_ch_ctl_reg = PCH_DPC_AUX_CH_CTL;
  702.                 name = "DPDDC-C";
  703.                 break;
  704.         case PORT_D:
  705.                 intel_dp->aux_ch_ctl_reg = PCH_DPD_AUX_CH_CTL;
  706.                 name = "DPDDC-D";
  707.                 break;
  708.         default:
  709.                 BUG();
  710.         }
  711.  
  712.         if (!HAS_DDI(dev))
  713.                 intel_dp->aux_ch_ctl_reg = intel_dp->output_reg + 0x10;
  714.  
  715.         intel_dp->aux.name = name;
  716.         intel_dp->aux.dev = dev->dev;
  717.         intel_dp->aux.transfer = intel_dp_aux_transfer;
  718.  
  719.  
  720.         ret = drm_dp_aux_register(&intel_dp->aux);
  721.                 if (ret < 0) {
  722.                 DRM_ERROR("drm_dp_aux_register() for %s failed (%d)\n",
  723.                           name, ret);
  724.                 return;
  725.         }
  726. }
  727.  
  728. static void
  729. intel_dp_connector_unregister(struct intel_connector *intel_connector)
  730. {
  731.         struct intel_dp *intel_dp = intel_attached_dp(&intel_connector->base);
  732.  
  733.         intel_connector_unregister(intel_connector);
  734. }
  735.  
  736. static void
  737. hsw_dp_set_ddi_pll_sel(struct intel_crtc_config *pipe_config, int link_bw)
  738. {
  739.         switch (link_bw) {
  740.         case DP_LINK_BW_1_62:
  741.                 pipe_config->ddi_pll_sel = PORT_CLK_SEL_LCPLL_810;
  742.                 break;
  743.         case DP_LINK_BW_2_7:
  744.                 pipe_config->ddi_pll_sel = PORT_CLK_SEL_LCPLL_1350;
  745.                 break;
  746.         case DP_LINK_BW_5_4:
  747.                 pipe_config->ddi_pll_sel = PORT_CLK_SEL_LCPLL_2700;
  748.                 break;
  749.         }
  750. }
  751.  
  752. static void
  753. intel_dp_set_clock(struct intel_encoder *encoder,
  754.                    struct intel_crtc_config *pipe_config, int link_bw)
  755. {
  756.         struct drm_device *dev = encoder->base.dev;
  757.         const struct dp_link_dpll *divisor = NULL;
  758.         int i, count = 0;
  759.  
  760.         if (IS_G4X(dev)) {
  761.                 divisor = gen4_dpll;
  762.                 count = ARRAY_SIZE(gen4_dpll);
  763.         } else if (HAS_PCH_SPLIT(dev)) {
  764.                 divisor = pch_dpll;
  765.                 count = ARRAY_SIZE(pch_dpll);
  766.         } else if (IS_CHERRYVIEW(dev)) {
  767.                 divisor = chv_dpll;
  768.                 count = ARRAY_SIZE(chv_dpll);
  769.         } else if (IS_VALLEYVIEW(dev)) {
  770.                 divisor = vlv_dpll;
  771.                 count = ARRAY_SIZE(vlv_dpll);
  772.         }
  773.  
  774.         if (divisor && count) {
  775.                 for (i = 0; i < count; i++) {
  776.                         if (link_bw == divisor[i].link_bw) {
  777.                                 pipe_config->dpll = divisor[i].dpll;
  778.                                 pipe_config->clock_set = true;
  779.                                 break;
  780.                         }
  781.                 }
  782.         }
  783. }
  784.  
  785. static void
  786. intel_dp_set_m2_n2(struct intel_crtc *crtc, struct intel_link_m_n *m_n)
  787. {
  788.         struct drm_device *dev = crtc->base.dev;
  789.         struct drm_i915_private *dev_priv = dev->dev_private;
  790.         enum transcoder transcoder = crtc->config.cpu_transcoder;
  791.  
  792.         I915_WRITE(PIPE_DATA_M2(transcoder),
  793.                 TU_SIZE(m_n->tu) | m_n->gmch_m);
  794.         I915_WRITE(PIPE_DATA_N2(transcoder), m_n->gmch_n);
  795.         I915_WRITE(PIPE_LINK_M2(transcoder), m_n->link_m);
  796.         I915_WRITE(PIPE_LINK_N2(transcoder), m_n->link_n);
  797. }
  798.  
  799. bool
  800. intel_dp_compute_config(struct intel_encoder *encoder,
  801.                         struct intel_crtc_config *pipe_config)
  802. {
  803.         struct drm_device *dev = encoder->base.dev;
  804.         struct drm_i915_private *dev_priv = dev->dev_private;
  805.         struct drm_display_mode *adjusted_mode = &pipe_config->adjusted_mode;
  806.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  807.         enum port port = dp_to_dig_port(intel_dp)->port;
  808.         struct intel_crtc *intel_crtc = encoder->new_crtc;
  809.         struct intel_connector *intel_connector = intel_dp->attached_connector;
  810.         int lane_count, clock;
  811.         int min_lane_count = 1;
  812.         int max_lane_count = intel_dp_max_lane_count(intel_dp);
  813.         /* Conveniently, the link BW constants become indices with a shift...*/
  814.         int min_clock = 0;
  815.         int max_clock = intel_dp_max_link_bw(intel_dp) >> 3;
  816.         int bpp, mode_rate;
  817.         static int bws[] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7, DP_LINK_BW_5_4 };
  818.         int link_avail, link_clock;
  819.  
  820.         if (HAS_PCH_SPLIT(dev) && !HAS_DDI(dev) && port != PORT_A)
  821.                 pipe_config->has_pch_encoder = true;
  822.  
  823.         pipe_config->has_dp_encoder = true;
  824.         pipe_config->has_audio = intel_dp->has_audio;
  825.  
  826.         if (is_edp(intel_dp) && intel_connector->panel.fixed_mode) {
  827.                 intel_fixed_panel_mode(intel_connector->panel.fixed_mode,
  828.                                        adjusted_mode);
  829.                 if (!HAS_PCH_SPLIT(dev))
  830.                         intel_gmch_panel_fitting(intel_crtc, pipe_config,
  831.                                                  intel_connector->panel.fitting_mode);
  832.                 else
  833.                         intel_pch_panel_fitting(intel_crtc, pipe_config,
  834.                                                 intel_connector->panel.fitting_mode);
  835.         }
  836.  
  837.         if (adjusted_mode->flags & DRM_MODE_FLAG_DBLCLK)
  838.                 return false;
  839.  
  840.         DRM_DEBUG_KMS("DP link computation with max lane count %i "
  841.                       "max bw %02x pixel clock %iKHz\n",
  842.                       max_lane_count, bws[max_clock],
  843.                       adjusted_mode->crtc_clock);
  844.  
  845.         /* Walk through all bpp values. Luckily they're all nicely spaced with 2
  846.          * bpc in between. */
  847.         bpp = pipe_config->pipe_bpp;
  848.         if (is_edp(intel_dp)) {
  849.                 if (dev_priv->vbt.edp_bpp && dev_priv->vbt.edp_bpp < bpp) {
  850.                 DRM_DEBUG_KMS("clamping bpp for eDP panel to BIOS-provided %i\n",
  851.                               dev_priv->vbt.edp_bpp);
  852.                 bpp = dev_priv->vbt.edp_bpp;
  853.         }
  854.  
  855.                 if (IS_BROADWELL(dev)) {
  856.                         /* Yes, it's an ugly hack. */
  857.                         min_lane_count = max_lane_count;
  858.                         DRM_DEBUG_KMS("forcing lane count to max (%u) on BDW\n",
  859.                                       min_lane_count);
  860.                 } else if (dev_priv->vbt.edp_lanes) {
  861.                         min_lane_count = min(dev_priv->vbt.edp_lanes,
  862.                                              max_lane_count);
  863.                         DRM_DEBUG_KMS("using min %u lanes per VBT\n",
  864.                                       min_lane_count);
  865.                 }
  866.  
  867.                 if (dev_priv->vbt.edp_rate) {
  868.                         min_clock = min(dev_priv->vbt.edp_rate >> 3, max_clock);
  869.                         DRM_DEBUG_KMS("using min %02x link bw per VBT\n",
  870.                                       bws[min_clock]);
  871.                 }
  872.         }
  873.  
  874.         for (; bpp >= 6*3; bpp -= 2*3) {
  875.                 mode_rate = intel_dp_link_required(adjusted_mode->crtc_clock,
  876.                                                    bpp);
  877.  
  878.                 for (clock = min_clock; clock <= max_clock; clock++) {
  879.                 for (lane_count = min_lane_count; lane_count <= max_lane_count; lane_count <<= 1) {
  880.                                 link_clock = drm_dp_bw_code_to_link_rate(bws[clock]);
  881.                                 link_avail = intel_dp_max_data_rate(link_clock,
  882.                                                                     lane_count);
  883.  
  884.                                 if (mode_rate <= link_avail) {
  885.                                         goto found;
  886.                                 }
  887.                         }
  888.                 }
  889.         }
  890.  
  891.                 return false;
  892.  
  893. found:
  894.         if (intel_dp->color_range_auto) {
  895.                 /*
  896.                  * See:
  897.                  * CEA-861-E - 5.1 Default Encoding Parameters
  898.                  * VESA DisplayPort Ver.1.2a - 5.1.1.1 Video Colorimetry
  899.                  */
  900.                 if (bpp != 18 && drm_match_cea_mode(adjusted_mode) > 1)
  901.                         intel_dp->color_range = DP_COLOR_RANGE_16_235;
  902.                 else
  903.                         intel_dp->color_range = 0;
  904.         }
  905.  
  906.         if (intel_dp->color_range)
  907.                 pipe_config->limited_color_range = true;
  908.  
  909.                                 intel_dp->link_bw = bws[clock];
  910.                                 intel_dp->lane_count = lane_count;
  911.         pipe_config->pipe_bpp = bpp;
  912.         pipe_config->port_clock = drm_dp_bw_code_to_link_rate(intel_dp->link_bw);
  913.  
  914.         DRM_DEBUG_KMS("DP link bw %02x lane count %d clock %d bpp %d\n",
  915.                                        intel_dp->link_bw, intel_dp->lane_count,
  916.                       pipe_config->port_clock, bpp);
  917.                                 DRM_DEBUG_KMS("DP link bw required %i available %i\n",
  918.                                               mode_rate, link_avail);
  919.  
  920.         intel_link_compute_m_n(bpp, lane_count,
  921.                                adjusted_mode->crtc_clock,
  922.                                pipe_config->port_clock,
  923.                                &pipe_config->dp_m_n);
  924.  
  925.         if (intel_connector->panel.downclock_mode != NULL &&
  926.                 intel_dp->drrs_state.type == SEAMLESS_DRRS_SUPPORT) {
  927.                         intel_link_compute_m_n(bpp, lane_count,
  928.                                 intel_connector->panel.downclock_mode->clock,
  929.                                 pipe_config->port_clock,
  930.                                 &pipe_config->dp_m2_n2);
  931.         }
  932.  
  933.         if (HAS_DDI(dev))
  934.                 hsw_dp_set_ddi_pll_sel(pipe_config, intel_dp->link_bw);
  935.         else
  936.         intel_dp_set_clock(encoder, pipe_config, intel_dp->link_bw);
  937.  
  938.         return true;
  939. }
  940.  
  941. static void ironlake_set_pll_cpu_edp(struct intel_dp *intel_dp)
  942. {
  943.         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
  944.         struct intel_crtc *crtc = to_intel_crtc(dig_port->base.base.crtc);
  945.         struct drm_device *dev = crtc->base.dev;
  946.         struct drm_i915_private *dev_priv = dev->dev_private;
  947.         u32 dpa_ctl;
  948.  
  949.         DRM_DEBUG_KMS("eDP PLL enable for clock %d\n", crtc->config.port_clock);
  950.         dpa_ctl = I915_READ(DP_A);
  951.         dpa_ctl &= ~DP_PLL_FREQ_MASK;
  952.  
  953.         if (crtc->config.port_clock == 162000) {
  954.                 /* For a long time we've carried around a ILK-DevA w/a for the
  955.                  * 160MHz clock. If we're really unlucky, it's still required.
  956.                  */
  957.                 DRM_DEBUG_KMS("160MHz cpu eDP clock, might need ilk devA w/a\n");
  958.                 dpa_ctl |= DP_PLL_FREQ_160MHZ;
  959.                 intel_dp->DP |= DP_PLL_FREQ_160MHZ;
  960.         } else {
  961.                 dpa_ctl |= DP_PLL_FREQ_270MHZ;
  962.                 intel_dp->DP |= DP_PLL_FREQ_270MHZ;
  963.         }
  964.  
  965.         I915_WRITE(DP_A, dpa_ctl);
  966.  
  967.         POSTING_READ(DP_A);
  968.         udelay(500);
  969. }
  970.  
  971. static void intel_dp_prepare(struct intel_encoder *encoder)
  972. {
  973.         struct drm_device *dev = encoder->base.dev;
  974.         struct drm_i915_private *dev_priv = dev->dev_private;
  975.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  976.         enum port port = dp_to_dig_port(intel_dp)->port;
  977.         struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
  978.         struct drm_display_mode *adjusted_mode = &crtc->config.adjusted_mode;
  979.  
  980.         /*
  981.          * There are four kinds of DP registers:
  982.          *
  983.          *      IBX PCH
  984.          *      SNB CPU
  985.          *      IVB CPU
  986.          *      CPT PCH
  987.          *
  988.          * IBX PCH and CPU are the same for almost everything,
  989.          * except that the CPU DP PLL is configured in this
  990.          * register
  991.          *
  992.          * CPT PCH is quite different, having many bits moved
  993.          * to the TRANS_DP_CTL register instead. That
  994.          * configuration happens (oddly) in ironlake_pch_enable
  995.          */
  996.  
  997.         /* Preserve the BIOS-computed detected bit. This is
  998.          * supposed to be read-only.
  999.          */
  1000.         intel_dp->DP = I915_READ(intel_dp->output_reg) & DP_DETECTED;
  1001.  
  1002.         /* Handle DP bits in common between all three register formats */
  1003.         intel_dp->DP |= DP_VOLTAGE_0_4 | DP_PRE_EMPHASIS_0;
  1004.         intel_dp->DP |= DP_PORT_WIDTH(intel_dp->lane_count);
  1005.  
  1006.         if (crtc->config.has_audio) {
  1007.                 DRM_DEBUG_DRIVER("Enabling DP audio on pipe %c\n",
  1008.                                  pipe_name(crtc->pipe));
  1009.                 intel_dp->DP |= DP_AUDIO_OUTPUT_ENABLE;
  1010.                 intel_write_eld(&encoder->base, adjusted_mode);
  1011.         }
  1012.  
  1013.         /* Split out the IBX/CPU vs CPT settings */
  1014.  
  1015.         if (port == PORT_A && IS_GEN7(dev) && !IS_VALLEYVIEW(dev)) {
  1016.                 if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
  1017.                         intel_dp->DP |= DP_SYNC_HS_HIGH;
  1018.                 if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
  1019.                         intel_dp->DP |= DP_SYNC_VS_HIGH;
  1020.                 intel_dp->DP |= DP_LINK_TRAIN_OFF_CPT;
  1021.  
  1022.                 if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
  1023.                         intel_dp->DP |= DP_ENHANCED_FRAMING;
  1024.  
  1025.                 intel_dp->DP |= crtc->pipe << 29;
  1026.         } else if (!HAS_PCH_CPT(dev) || port == PORT_A) {
  1027.                 if (!HAS_PCH_SPLIT(dev) && !IS_VALLEYVIEW(dev))
  1028.                 intel_dp->DP |= intel_dp->color_range;
  1029.  
  1030.                 if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
  1031.                         intel_dp->DP |= DP_SYNC_HS_HIGH;
  1032.                 if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
  1033.                         intel_dp->DP |= DP_SYNC_VS_HIGH;
  1034.                 intel_dp->DP |= DP_LINK_TRAIN_OFF;
  1035.  
  1036.                 if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
  1037.                 intel_dp->DP |= DP_ENHANCED_FRAMING;
  1038.  
  1039.                 if (!IS_CHERRYVIEW(dev)) {
  1040.                 if (crtc->pipe == 1)
  1041.                 intel_dp->DP |= DP_PIPEB_SELECT;
  1042.         } else {
  1043.                         intel_dp->DP |= DP_PIPE_SELECT_CHV(crtc->pipe);
  1044.                 }
  1045.         } else {
  1046.                 intel_dp->DP |= DP_LINK_TRAIN_OFF_CPT;
  1047.         }
  1048. }
  1049.  
  1050. #define IDLE_ON_MASK            (PP_ON | PP_SEQUENCE_MASK | 0                     | PP_SEQUENCE_STATE_MASK)
  1051. #define IDLE_ON_VALUE           (PP_ON | PP_SEQUENCE_NONE | 0                     | PP_SEQUENCE_STATE_ON_IDLE)
  1052.  
  1053. #define IDLE_OFF_MASK           (PP_ON | PP_SEQUENCE_MASK | 0                     | 0)
  1054. #define IDLE_OFF_VALUE          (0     | PP_SEQUENCE_NONE | 0                     | 0)
  1055.  
  1056. #define IDLE_CYCLE_MASK         (PP_ON | PP_SEQUENCE_MASK | PP_CYCLE_DELAY_ACTIVE | PP_SEQUENCE_STATE_MASK)
  1057. #define IDLE_CYCLE_VALUE        (0     | PP_SEQUENCE_NONE | 0                     | PP_SEQUENCE_STATE_OFF_IDLE)
  1058.  
  1059. static void wait_panel_status(struct intel_dp *intel_dp,
  1060.                                        u32 mask,
  1061.                                        u32 value)
  1062. {
  1063.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1064.         struct drm_i915_private *dev_priv = dev->dev_private;
  1065.         u32 pp_stat_reg, pp_ctrl_reg;
  1066.  
  1067.         pp_stat_reg = _pp_stat_reg(intel_dp);
  1068.         pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
  1069.  
  1070.         DRM_DEBUG_KMS("mask %08x value %08x status %08x control %08x\n",
  1071.                       mask, value,
  1072.                         I915_READ(pp_stat_reg),
  1073.                         I915_READ(pp_ctrl_reg));
  1074.  
  1075.         if (_wait_for((I915_READ(pp_stat_reg) & mask) == value, 5000, 10)) {
  1076.                 DRM_ERROR("Panel status timeout: status %08x control %08x\n",
  1077.                                 I915_READ(pp_stat_reg),
  1078.                                 I915_READ(pp_ctrl_reg));
  1079.         }
  1080.  
  1081.         DRM_DEBUG_KMS("Wait complete\n");
  1082. }
  1083.  
  1084. static void wait_panel_on(struct intel_dp *intel_dp)
  1085. {
  1086.         DRM_DEBUG_KMS("Wait for panel power on\n");
  1087.         wait_panel_status(intel_dp, IDLE_ON_MASK, IDLE_ON_VALUE);
  1088. }
  1089.  
  1090. static void wait_panel_off(struct intel_dp *intel_dp)
  1091. {
  1092.         DRM_DEBUG_KMS("Wait for panel power off time\n");
  1093.         wait_panel_status(intel_dp, IDLE_OFF_MASK, IDLE_OFF_VALUE);
  1094. }
  1095.  
  1096. static void wait_panel_power_cycle(struct intel_dp *intel_dp)
  1097. {
  1098.         DRM_DEBUG_KMS("Wait for panel power cycle\n");
  1099.  
  1100.         /* When we disable the VDD override bit last we have to do the manual
  1101.          * wait. */
  1102.         wait_remaining_ms_from_jiffies(intel_dp->last_power_cycle,
  1103.                                        intel_dp->panel_power_cycle_delay);
  1104.  
  1105.         wait_panel_status(intel_dp, IDLE_CYCLE_MASK, IDLE_CYCLE_VALUE);
  1106. }
  1107.  
  1108. static void wait_backlight_on(struct intel_dp *intel_dp)
  1109. {
  1110.         wait_remaining_ms_from_jiffies(intel_dp->last_power_on,
  1111.                                        intel_dp->backlight_on_delay);
  1112. }
  1113.  
  1114. static void edp_wait_backlight_off(struct intel_dp *intel_dp)
  1115. {
  1116.         wait_remaining_ms_from_jiffies(intel_dp->last_backlight_off,
  1117.                                        intel_dp->backlight_off_delay);
  1118. }
  1119.  
  1120. /* Read the current pp_control value, unlocking the register if it
  1121.  * is locked
  1122.  */
  1123.  
  1124. static  u32 ironlake_get_pp_control(struct intel_dp *intel_dp)
  1125. {
  1126.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1127.         struct drm_i915_private *dev_priv = dev->dev_private;
  1128.         u32 control;
  1129.  
  1130.         control = I915_READ(_pp_ctrl_reg(intel_dp));
  1131.         control &= ~PANEL_UNLOCK_MASK;
  1132.         control |= PANEL_UNLOCK_REGS;
  1133.         return control;
  1134. }
  1135.  
  1136. static bool _edp_panel_vdd_on(struct intel_dp *intel_dp)
  1137. {
  1138.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1139.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  1140.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  1141.         struct drm_i915_private *dev_priv = dev->dev_private;
  1142.         enum intel_display_power_domain power_domain;
  1143.         u32 pp;
  1144.         u32 pp_stat_reg, pp_ctrl_reg;
  1145.         bool need_to_disable = !intel_dp->want_panel_vdd;
  1146.  
  1147.         if (!is_edp(intel_dp))
  1148.                 return false;
  1149.  
  1150.         intel_dp->want_panel_vdd = true;
  1151.  
  1152.         if (edp_have_panel_vdd(intel_dp))
  1153.                 return need_to_disable;
  1154.  
  1155.         power_domain = intel_display_port_power_domain(intel_encoder);
  1156.         intel_display_power_get(dev_priv, power_domain);
  1157.  
  1158.         DRM_DEBUG_KMS("Turning eDP VDD on\n");
  1159.  
  1160.         if (!edp_have_panel_power(intel_dp))
  1161.                 wait_panel_power_cycle(intel_dp);
  1162.  
  1163.         pp = ironlake_get_pp_control(intel_dp);
  1164.         pp |= EDP_FORCE_VDD;
  1165.  
  1166.         pp_stat_reg = _pp_stat_reg(intel_dp);
  1167.         pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
  1168.  
  1169.         I915_WRITE(pp_ctrl_reg, pp);
  1170.         POSTING_READ(pp_ctrl_reg);
  1171.         DRM_DEBUG_KMS("PP_STATUS: 0x%08x PP_CONTROL: 0x%08x\n",
  1172.                         I915_READ(pp_stat_reg), I915_READ(pp_ctrl_reg));
  1173.         /*
  1174.          * If the panel wasn't on, delay before accessing aux channel
  1175.          */
  1176.         if (!edp_have_panel_power(intel_dp)) {
  1177.                 DRM_DEBUG_KMS("eDP was not running\n");
  1178.                 msleep(intel_dp->panel_power_up_delay);
  1179.         }
  1180.  
  1181.         return need_to_disable;
  1182. }
  1183.  
  1184. void intel_edp_panel_vdd_on(struct intel_dp *intel_dp)
  1185. {
  1186.         if (is_edp(intel_dp)) {
  1187.                 bool vdd = _edp_panel_vdd_on(intel_dp);
  1188.  
  1189.                 WARN(!vdd, "eDP VDD already requested on\n");
  1190.         }
  1191. }
  1192.  
  1193. static void edp_panel_vdd_off_sync(struct intel_dp *intel_dp)
  1194. {
  1195.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1196.         struct drm_i915_private *dev_priv = dev->dev_private;
  1197.         u32 pp;
  1198.         u32 pp_stat_reg, pp_ctrl_reg;
  1199.  
  1200.         WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
  1201.  
  1202.         if (!intel_dp->want_panel_vdd && edp_have_panel_vdd(intel_dp)) {
  1203.                 struct intel_digital_port *intel_dig_port =
  1204.                                                 dp_to_dig_port(intel_dp);
  1205.                 struct intel_encoder *intel_encoder = &intel_dig_port->base;
  1206.                 enum intel_display_power_domain power_domain;
  1207.  
  1208.                 DRM_DEBUG_KMS("Turning eDP VDD off\n");
  1209.  
  1210.                 pp = ironlake_get_pp_control(intel_dp);
  1211.         pp &= ~EDP_FORCE_VDD;
  1212.  
  1213.                 pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
  1214.                 pp_stat_reg = _pp_stat_reg(intel_dp);
  1215.  
  1216.                 I915_WRITE(pp_ctrl_reg, pp);
  1217.                 POSTING_READ(pp_ctrl_reg);
  1218.  
  1219.         /* Make sure sequencer is idle before allowing subsequent activity */
  1220.                 DRM_DEBUG_KMS("PP_STATUS: 0x%08x PP_CONTROL: 0x%08x\n",
  1221.                 I915_READ(pp_stat_reg), I915_READ(pp_ctrl_reg));
  1222.  
  1223.                 if ((pp & POWER_TARGET_ON) == 0)
  1224.                         intel_dp->last_power_cycle = jiffies;
  1225.  
  1226.                 power_domain = intel_display_port_power_domain(intel_encoder);
  1227.                 intel_display_power_put(dev_priv, power_domain);
  1228.         }
  1229. }
  1230.  
  1231. static void edp_panel_vdd_work(struct work_struct *__work)
  1232. {
  1233.         struct intel_dp *intel_dp = container_of(to_delayed_work(__work),
  1234.                                                  struct intel_dp, panel_vdd_work);
  1235.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1236.  
  1237.         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
  1238.         edp_panel_vdd_off_sync(intel_dp);
  1239.         drm_modeset_unlock(&dev->mode_config.connection_mutex);
  1240. }
  1241.  
  1242. static void edp_panel_vdd_schedule_off(struct intel_dp *intel_dp)
  1243. {
  1244.         unsigned long delay;
  1245.  
  1246.         /*
  1247.          * Queue the timer to fire a long time from now (relative to the power
  1248.          * down delay) to keep the panel power up across a sequence of
  1249.          * operations.
  1250.          */
  1251.         delay = msecs_to_jiffies(intel_dp->panel_power_cycle_delay * 5);
  1252.         schedule_delayed_work(&intel_dp->panel_vdd_work, delay);
  1253. }
  1254.  
  1255. static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync)
  1256. {
  1257.         if (!is_edp(intel_dp))
  1258.                 return;
  1259.  
  1260.         WARN(!intel_dp->want_panel_vdd, "eDP VDD not forced on");
  1261.  
  1262.         intel_dp->want_panel_vdd = false;
  1263.  
  1264.         if (sync)
  1265.                 edp_panel_vdd_off_sync(intel_dp);
  1266.         else
  1267.                 edp_panel_vdd_schedule_off(intel_dp);
  1268. }
  1269.  
  1270. void intel_edp_panel_on(struct intel_dp *intel_dp)
  1271. {
  1272.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1273.         struct drm_i915_private *dev_priv = dev->dev_private;
  1274.         u32 pp;
  1275.         u32 pp_ctrl_reg;
  1276.  
  1277.         if (!is_edp(intel_dp))
  1278.                 return;
  1279.  
  1280.         DRM_DEBUG_KMS("Turn eDP power on\n");
  1281.  
  1282.         if (edp_have_panel_power(intel_dp)) {
  1283.                 DRM_DEBUG_KMS("eDP power already on\n");
  1284.                 return;
  1285.         }
  1286.  
  1287.         wait_panel_power_cycle(intel_dp);
  1288.  
  1289.         pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
  1290.         pp = ironlake_get_pp_control(intel_dp);
  1291.         if (IS_GEN5(dev)) {
  1292.         /* ILK workaround: disable reset around power sequence */
  1293.         pp &= ~PANEL_POWER_RESET;
  1294.                 I915_WRITE(pp_ctrl_reg, pp);
  1295.                 POSTING_READ(pp_ctrl_reg);
  1296.         }
  1297.  
  1298.         pp |= POWER_TARGET_ON;
  1299.         if (!IS_GEN5(dev))
  1300.                 pp |= PANEL_POWER_RESET;
  1301.  
  1302.         I915_WRITE(pp_ctrl_reg, pp);
  1303.         POSTING_READ(pp_ctrl_reg);
  1304.  
  1305.         wait_panel_on(intel_dp);
  1306.         intel_dp->last_power_on = jiffies;
  1307.  
  1308.         if (IS_GEN5(dev)) {
  1309.         pp |= PANEL_POWER_RESET; /* restore panel reset bit */
  1310.                 I915_WRITE(pp_ctrl_reg, pp);
  1311.                 POSTING_READ(pp_ctrl_reg);
  1312.         }
  1313. }
  1314.  
  1315. void intel_edp_panel_off(struct intel_dp *intel_dp)
  1316. {
  1317.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  1318.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  1319.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1320.         struct drm_i915_private *dev_priv = dev->dev_private;
  1321.         enum intel_display_power_domain power_domain;
  1322.         u32 pp;
  1323.         u32 pp_ctrl_reg;
  1324.  
  1325.         if (!is_edp(intel_dp))
  1326.                 return;
  1327.  
  1328.         DRM_DEBUG_KMS("Turn eDP power off\n");
  1329.  
  1330.         WARN(!intel_dp->want_panel_vdd, "Need VDD to turn off panel\n");
  1331.  
  1332.         pp = ironlake_get_pp_control(intel_dp);
  1333.         /* We need to switch off panel power _and_ force vdd, for otherwise some
  1334.          * panels get very unhappy and cease to work. */
  1335.         pp &= ~(POWER_TARGET_ON | PANEL_POWER_RESET | EDP_FORCE_VDD |
  1336.                 EDP_BLC_ENABLE);
  1337.  
  1338.         pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
  1339.  
  1340.         intel_dp->want_panel_vdd = false;
  1341.  
  1342.         I915_WRITE(pp_ctrl_reg, pp);
  1343.         POSTING_READ(pp_ctrl_reg);
  1344.  
  1345.         intel_dp->last_power_cycle = jiffies;
  1346.         wait_panel_off(intel_dp);
  1347.  
  1348.         /* We got a reference when we enabled the VDD. */
  1349.         power_domain = intel_display_port_power_domain(intel_encoder);
  1350.         intel_display_power_put(dev_priv, power_domain);
  1351. }
  1352.  
  1353. void intel_edp_backlight_on(struct intel_dp *intel_dp)
  1354. {
  1355.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  1356.         struct drm_device *dev = intel_dig_port->base.base.dev;
  1357.         struct drm_i915_private *dev_priv = dev->dev_private;
  1358.         u32 pp;
  1359.         u32 pp_ctrl_reg;
  1360.  
  1361.         if (!is_edp(intel_dp))
  1362.                 return;
  1363.  
  1364.         DRM_DEBUG_KMS("\n");
  1365.  
  1366.         intel_panel_enable_backlight(intel_dp->attached_connector);
  1367.  
  1368.         /*
  1369.          * If we enable the backlight right away following a panel power
  1370.          * on, we may see slight flicker as the panel syncs with the eDP
  1371.          * link.  So delay a bit to make sure the image is solid before
  1372.          * allowing it to appear.
  1373.          */
  1374.         wait_backlight_on(intel_dp);
  1375.         pp = ironlake_get_pp_control(intel_dp);
  1376.         pp |= EDP_BLC_ENABLE;
  1377.  
  1378.         pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
  1379.  
  1380.         I915_WRITE(pp_ctrl_reg, pp);
  1381.         POSTING_READ(pp_ctrl_reg);
  1382. }
  1383.  
  1384. void intel_edp_backlight_off(struct intel_dp *intel_dp)
  1385. {
  1386.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1387.         struct drm_i915_private *dev_priv = dev->dev_private;
  1388.         u32 pp;
  1389.         u32 pp_ctrl_reg;
  1390.  
  1391.         if (!is_edp(intel_dp))
  1392.                 return;
  1393.  
  1394.         DRM_DEBUG_KMS("\n");
  1395.         pp = ironlake_get_pp_control(intel_dp);
  1396.         pp &= ~EDP_BLC_ENABLE;
  1397.  
  1398.         pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
  1399.  
  1400.         I915_WRITE(pp_ctrl_reg, pp);
  1401.         POSTING_READ(pp_ctrl_reg);
  1402.         intel_dp->last_backlight_off = jiffies;
  1403.  
  1404.         edp_wait_backlight_off(intel_dp);
  1405.  
  1406.         intel_panel_disable_backlight(intel_dp->attached_connector);
  1407. }
  1408.  
  1409. static void ironlake_edp_pll_on(struct intel_dp *intel_dp)
  1410. {
  1411.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  1412.         struct drm_crtc *crtc = intel_dig_port->base.base.crtc;
  1413.         struct drm_device *dev = crtc->dev;
  1414.         struct drm_i915_private *dev_priv = dev->dev_private;
  1415.         u32 dpa_ctl;
  1416.  
  1417.         assert_pipe_disabled(dev_priv,
  1418.                              to_intel_crtc(crtc)->pipe);
  1419.  
  1420.         DRM_DEBUG_KMS("\n");
  1421.         dpa_ctl = I915_READ(DP_A);
  1422.         WARN(dpa_ctl & DP_PLL_ENABLE, "dp pll on, should be off\n");
  1423.         WARN(dpa_ctl & DP_PORT_EN, "dp port still on, should be off\n");
  1424.  
  1425.         /* We don't adjust intel_dp->DP while tearing down the link, to
  1426.          * facilitate link retraining (e.g. after hotplug). Hence clear all
  1427.          * enable bits here to ensure that we don't enable too much. */
  1428.         intel_dp->DP &= ~(DP_PORT_EN | DP_AUDIO_OUTPUT_ENABLE);
  1429.         intel_dp->DP |= DP_PLL_ENABLE;
  1430.         I915_WRITE(DP_A, intel_dp->DP);
  1431.         POSTING_READ(DP_A);
  1432.         udelay(200);
  1433. }
  1434.  
  1435. static void ironlake_edp_pll_off(struct intel_dp *intel_dp)
  1436. {
  1437.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  1438.         struct drm_crtc *crtc = intel_dig_port->base.base.crtc;
  1439.         struct drm_device *dev = crtc->dev;
  1440.         struct drm_i915_private *dev_priv = dev->dev_private;
  1441.         u32 dpa_ctl;
  1442.  
  1443.         assert_pipe_disabled(dev_priv,
  1444.                              to_intel_crtc(crtc)->pipe);
  1445.  
  1446.         dpa_ctl = I915_READ(DP_A);
  1447.         WARN((dpa_ctl & DP_PLL_ENABLE) == 0,
  1448.              "dp pll off, should be on\n");
  1449.         WARN(dpa_ctl & DP_PORT_EN, "dp port still on, should be off\n");
  1450.  
  1451.         /* We can't rely on the value tracked for the DP register in
  1452.          * intel_dp->DP because link_down must not change that (otherwise link
  1453.          * re-training will fail. */
  1454.         dpa_ctl &= ~DP_PLL_ENABLE;
  1455.         I915_WRITE(DP_A, dpa_ctl);
  1456.         POSTING_READ(DP_A);
  1457.         udelay(200);
  1458. }
  1459.  
  1460. /* If the sink supports it, try to set the power state appropriately */
  1461. void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode)
  1462. {
  1463.         int ret, i;
  1464.  
  1465.         /* Should have a valid DPCD by this point */
  1466.         if (intel_dp->dpcd[DP_DPCD_REV] < 0x11)
  1467.                 return;
  1468.  
  1469.         if (mode != DRM_MODE_DPMS_ON) {
  1470.                 ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER,
  1471.                                                   DP_SET_POWER_D3);
  1472.                 if (ret != 1)
  1473.                         DRM_DEBUG_DRIVER("failed to write sink power state\n");
  1474.         } else {
  1475.                 /*
  1476.                  * When turning on, we need to retry for 1ms to give the sink
  1477.                  * time to wake up.
  1478.                  */
  1479.                 for (i = 0; i < 3; i++) {
  1480.                         ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER,
  1481.                                                           DP_SET_POWER_D0);
  1482.                         if (ret == 1)
  1483.                                 break;
  1484.                         msleep(1);
  1485.                 }
  1486.         }
  1487. }
  1488.  
  1489. static bool intel_dp_get_hw_state(struct intel_encoder *encoder,
  1490.                                   enum pipe *pipe)
  1491. {
  1492.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  1493.         enum port port = dp_to_dig_port(intel_dp)->port;
  1494.         struct drm_device *dev = encoder->base.dev;
  1495.         struct drm_i915_private *dev_priv = dev->dev_private;
  1496.         enum intel_display_power_domain power_domain;
  1497.         u32 tmp;
  1498.  
  1499.         power_domain = intel_display_port_power_domain(encoder);
  1500.         if (!intel_display_power_enabled(dev_priv, power_domain))
  1501.                 return false;
  1502.  
  1503.         tmp = I915_READ(intel_dp->output_reg);
  1504.  
  1505.         if (!(tmp & DP_PORT_EN))
  1506.                 return false;
  1507.  
  1508.         if (port == PORT_A && IS_GEN7(dev) && !IS_VALLEYVIEW(dev)) {
  1509.                 *pipe = PORT_TO_PIPE_CPT(tmp);
  1510.         } else if (IS_CHERRYVIEW(dev)) {
  1511.                 *pipe = DP_PORT_TO_PIPE_CHV(tmp);
  1512.         } else if (!HAS_PCH_CPT(dev) || port == PORT_A) {
  1513.                 *pipe = PORT_TO_PIPE(tmp);
  1514.         } else {
  1515.                 u32 trans_sel;
  1516.                 u32 trans_dp;
  1517.                 int i;
  1518.  
  1519.                 switch (intel_dp->output_reg) {
  1520.                 case PCH_DP_B:
  1521.                         trans_sel = TRANS_DP_PORT_SEL_B;
  1522.                         break;
  1523.                 case PCH_DP_C:
  1524.                         trans_sel = TRANS_DP_PORT_SEL_C;
  1525.                         break;
  1526.                 case PCH_DP_D:
  1527.                         trans_sel = TRANS_DP_PORT_SEL_D;
  1528.                         break;
  1529.                 default:
  1530.                         return true;
  1531.                 }
  1532.  
  1533.                 for_each_pipe(i) {
  1534.                         trans_dp = I915_READ(TRANS_DP_CTL(i));
  1535.                         if ((trans_dp & TRANS_DP_PORT_SEL_MASK) == trans_sel) {
  1536.                                 *pipe = i;
  1537.                                 return true;
  1538.                         }
  1539.                 }
  1540.  
  1541.                 DRM_DEBUG_KMS("No pipe for dp port 0x%x found\n",
  1542.                               intel_dp->output_reg);
  1543.         }
  1544.  
  1545.         return true;
  1546. }
  1547.  
  1548. static void intel_dp_get_config(struct intel_encoder *encoder,
  1549.                                 struct intel_crtc_config *pipe_config)
  1550. {
  1551.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  1552.         u32 tmp, flags = 0;
  1553.         struct drm_device *dev = encoder->base.dev;
  1554.         struct drm_i915_private *dev_priv = dev->dev_private;
  1555.         enum port port = dp_to_dig_port(intel_dp)->port;
  1556.         struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
  1557.         int dotclock;
  1558.  
  1559.         tmp = I915_READ(intel_dp->output_reg);
  1560.         if (tmp & DP_AUDIO_OUTPUT_ENABLE)
  1561.                 pipe_config->has_audio = true;
  1562.  
  1563.         if ((port == PORT_A) || !HAS_PCH_CPT(dev)) {
  1564.                 if (tmp & DP_SYNC_HS_HIGH)
  1565.                         flags |= DRM_MODE_FLAG_PHSYNC;
  1566.                 else
  1567.                         flags |= DRM_MODE_FLAG_NHSYNC;
  1568.  
  1569.                 if (tmp & DP_SYNC_VS_HIGH)
  1570.                         flags |= DRM_MODE_FLAG_PVSYNC;
  1571.                 else
  1572.                         flags |= DRM_MODE_FLAG_NVSYNC;
  1573.         } else {
  1574.                 tmp = I915_READ(TRANS_DP_CTL(crtc->pipe));
  1575.                 if (tmp & TRANS_DP_HSYNC_ACTIVE_HIGH)
  1576.                         flags |= DRM_MODE_FLAG_PHSYNC;
  1577.                 else
  1578.                         flags |= DRM_MODE_FLAG_NHSYNC;
  1579.  
  1580.                 if (tmp & TRANS_DP_VSYNC_ACTIVE_HIGH)
  1581.                         flags |= DRM_MODE_FLAG_PVSYNC;
  1582.                 else
  1583.                         flags |= DRM_MODE_FLAG_NVSYNC;
  1584.         }
  1585.  
  1586.         pipe_config->adjusted_mode.flags |= flags;
  1587.  
  1588.         pipe_config->has_dp_encoder = true;
  1589.  
  1590.         intel_dp_get_m_n(crtc, pipe_config);
  1591.  
  1592.         if (port == PORT_A) {
  1593.                 if ((I915_READ(DP_A) & DP_PLL_FREQ_MASK) == DP_PLL_FREQ_160MHZ)
  1594.                         pipe_config->port_clock = 162000;
  1595.                 else
  1596.                         pipe_config->port_clock = 270000;
  1597.         }
  1598.  
  1599.         dotclock = intel_dotclock_calculate(pipe_config->port_clock,
  1600.                                             &pipe_config->dp_m_n);
  1601.  
  1602.         if (HAS_PCH_SPLIT(dev_priv->dev) && port != PORT_A)
  1603.                 ironlake_check_encoder_dotclock(pipe_config, dotclock);
  1604.  
  1605.         pipe_config->adjusted_mode.crtc_clock = dotclock;
  1606.  
  1607.         if (is_edp(intel_dp) && dev_priv->vbt.edp_bpp &&
  1608.             pipe_config->pipe_bpp > dev_priv->vbt.edp_bpp) {
  1609.                 /*
  1610.                  * This is a big fat ugly hack.
  1611.                  *
  1612.                  * Some machines in UEFI boot mode provide us a VBT that has 18
  1613.                  * bpp and 1.62 GHz link bandwidth for eDP, which for reasons
  1614.                  * unknown we fail to light up. Yet the same BIOS boots up with
  1615.                  * 24 bpp and 2.7 GHz link. Use the same bpp as the BIOS uses as
  1616.                  * max, not what it tells us to use.
  1617.                  *
  1618.                  * Note: This will still be broken if the eDP panel is not lit
  1619.                  * up by the BIOS, and thus we can't get the mode at module
  1620.                  * load.
  1621.                  */
  1622.                 DRM_DEBUG_KMS("pipe has %d bpp for eDP panel, overriding BIOS-provided max %d bpp\n",
  1623.                               pipe_config->pipe_bpp, dev_priv->vbt.edp_bpp);
  1624.                 dev_priv->vbt.edp_bpp = pipe_config->pipe_bpp;
  1625.         }
  1626. }
  1627.  
  1628. static bool is_edp_psr(struct intel_dp *intel_dp)
  1629. {
  1630.         return intel_dp->psr_dpcd[0] & DP_PSR_IS_SUPPORTED;
  1631. }
  1632.  
  1633. static bool intel_edp_is_psr_enabled(struct drm_device *dev)
  1634. {
  1635.         struct drm_i915_private *dev_priv = dev->dev_private;
  1636.  
  1637.         if (!HAS_PSR(dev))
  1638.                 return false;
  1639.  
  1640.         return I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE;
  1641. }
  1642.  
  1643. static void intel_edp_psr_write_vsc(struct intel_dp *intel_dp,
  1644.                                     struct edp_vsc_psr *vsc_psr)
  1645. {
  1646.         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
  1647.         struct drm_device *dev = dig_port->base.base.dev;
  1648.         struct drm_i915_private *dev_priv = dev->dev_private;
  1649.         struct intel_crtc *crtc = to_intel_crtc(dig_port->base.base.crtc);
  1650.         u32 ctl_reg = HSW_TVIDEO_DIP_CTL(crtc->config.cpu_transcoder);
  1651.         u32 data_reg = HSW_TVIDEO_DIP_VSC_DATA(crtc->config.cpu_transcoder);
  1652.         uint32_t *data = (uint32_t *) vsc_psr;
  1653.         unsigned int i;
  1654.  
  1655.         /* As per BSPec (Pipe Video Data Island Packet), we need to disable
  1656.            the video DIP being updated before program video DIP data buffer
  1657.            registers for DIP being updated. */
  1658.         I915_WRITE(ctl_reg, 0);
  1659.         POSTING_READ(ctl_reg);
  1660.  
  1661.         for (i = 0; i < VIDEO_DIP_VSC_DATA_SIZE; i += 4) {
  1662.                 if (i < sizeof(struct edp_vsc_psr))
  1663.                         I915_WRITE(data_reg + i, *data++);
  1664.                 else
  1665.                         I915_WRITE(data_reg + i, 0);
  1666.         }
  1667.  
  1668.         I915_WRITE(ctl_reg, VIDEO_DIP_ENABLE_VSC_HSW);
  1669.         POSTING_READ(ctl_reg);
  1670. }
  1671.  
  1672. static void intel_edp_psr_setup(struct intel_dp *intel_dp)
  1673. {
  1674.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1675.         struct drm_i915_private *dev_priv = dev->dev_private;
  1676.         struct edp_vsc_psr psr_vsc;
  1677.  
  1678.         /* Prepare VSC packet as per EDP 1.3 spec, Table 3.10 */
  1679.         memset(&psr_vsc, 0, sizeof(psr_vsc));
  1680.         psr_vsc.sdp_header.HB0 = 0;
  1681.         psr_vsc.sdp_header.HB1 = 0x7;
  1682.         psr_vsc.sdp_header.HB2 = 0x2;
  1683.         psr_vsc.sdp_header.HB3 = 0x8;
  1684.         intel_edp_psr_write_vsc(intel_dp, &psr_vsc);
  1685.  
  1686.         /* Avoid continuous PSR exit by masking memup and hpd */
  1687.         I915_WRITE(EDP_PSR_DEBUG_CTL(dev), EDP_PSR_DEBUG_MASK_MEMUP |
  1688.                    EDP_PSR_DEBUG_MASK_HPD | EDP_PSR_DEBUG_MASK_LPSP);
  1689. }
  1690.  
  1691. static void intel_edp_psr_enable_sink(struct intel_dp *intel_dp)
  1692. {
  1693.         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
  1694.         struct drm_device *dev = dig_port->base.base.dev;
  1695.         struct drm_i915_private *dev_priv = dev->dev_private;
  1696.         uint32_t aux_clock_divider;
  1697.         int precharge = 0x3;
  1698.         int msg_size = 5;       /* Header(4) + Message(1) */
  1699.         bool only_standby = false;
  1700.  
  1701.         aux_clock_divider = intel_dp->get_aux_clock_divider(intel_dp, 0);
  1702.  
  1703.         if (IS_BROADWELL(dev) && dig_port->port != PORT_A)
  1704.                 only_standby = true;
  1705.  
  1706.         /* Enable PSR in sink */
  1707.         if (intel_dp->psr_dpcd[1] & DP_PSR_NO_TRAIN_ON_EXIT || only_standby)
  1708.                 drm_dp_dpcd_writeb(&intel_dp->aux, DP_PSR_EN_CFG,
  1709.                                    DP_PSR_ENABLE & ~DP_PSR_MAIN_LINK_ACTIVE);
  1710.         else
  1711.                 drm_dp_dpcd_writeb(&intel_dp->aux, DP_PSR_EN_CFG,
  1712.                                    DP_PSR_ENABLE | DP_PSR_MAIN_LINK_ACTIVE);
  1713.  
  1714.         /* Setup AUX registers */
  1715.         I915_WRITE(EDP_PSR_AUX_DATA1(dev), EDP_PSR_DPCD_COMMAND);
  1716.         I915_WRITE(EDP_PSR_AUX_DATA2(dev), EDP_PSR_DPCD_NORMAL_OPERATION);
  1717.         I915_WRITE(EDP_PSR_AUX_CTL(dev),
  1718.                    DP_AUX_CH_CTL_TIME_OUT_400us |
  1719.                    (msg_size << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
  1720.                    (precharge << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
  1721.                    (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT));
  1722. }
  1723.  
  1724. static void intel_edp_psr_enable_source(struct intel_dp *intel_dp)
  1725. {
  1726.         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
  1727.         struct drm_device *dev = dig_port->base.base.dev;
  1728.         struct drm_i915_private *dev_priv = dev->dev_private;
  1729.         uint32_t max_sleep_time = 0x1f;
  1730.         uint32_t idle_frames = 1;
  1731.         uint32_t val = 0x0;
  1732.         const uint32_t link_entry_time = EDP_PSR_MIN_LINK_ENTRY_TIME_8_LINES;
  1733.         bool only_standby = false;
  1734.  
  1735.         if (IS_BROADWELL(dev) && dig_port->port != PORT_A)
  1736.                 only_standby = true;
  1737.  
  1738.         if (intel_dp->psr_dpcd[1] & DP_PSR_NO_TRAIN_ON_EXIT || only_standby) {
  1739.                 val |= EDP_PSR_LINK_STANDBY;
  1740.                 val |= EDP_PSR_TP2_TP3_TIME_0us;
  1741.                 val |= EDP_PSR_TP1_TIME_0us;
  1742.                 val |= EDP_PSR_SKIP_AUX_EXIT;
  1743.                 val |= IS_BROADWELL(dev) ? BDW_PSR_SINGLE_FRAME : 0;
  1744.         } else
  1745.                 val |= EDP_PSR_LINK_DISABLE;
  1746.  
  1747.         I915_WRITE(EDP_PSR_CTL(dev), val |
  1748.                    (IS_BROADWELL(dev) ? 0 : link_entry_time) |
  1749.                    max_sleep_time << EDP_PSR_MAX_SLEEP_TIME_SHIFT |
  1750.                    idle_frames << EDP_PSR_IDLE_FRAME_SHIFT |
  1751.                    EDP_PSR_ENABLE);
  1752. }
  1753.  
  1754. static bool intel_edp_psr_match_conditions(struct intel_dp *intel_dp)
  1755. {
  1756.         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
  1757.         struct drm_device *dev = dig_port->base.base.dev;
  1758.         struct drm_i915_private *dev_priv = dev->dev_private;
  1759.         struct drm_crtc *crtc = dig_port->base.base.crtc;
  1760.         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
  1761.  
  1762.         lockdep_assert_held(&dev_priv->psr.lock);
  1763.         WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
  1764.         WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
  1765.  
  1766.         dev_priv->psr.source_ok = false;
  1767.  
  1768.         if (IS_HASWELL(dev) && dig_port->port != PORT_A) {
  1769.                 DRM_DEBUG_KMS("HSW ties PSR to DDI A (eDP)\n");
  1770.                 return false;
  1771.         }
  1772.  
  1773.         if (!i915.enable_psr) {
  1774.                 DRM_DEBUG_KMS("PSR disable by flag\n");
  1775.                 return false;
  1776.         }
  1777.  
  1778.         /* Below limitations aren't valid for Broadwell */
  1779.         if (IS_BROADWELL(dev))
  1780.                 goto out;
  1781.  
  1782.         if (I915_READ(HSW_STEREO_3D_CTL(intel_crtc->config.cpu_transcoder)) &
  1783.             S3D_ENABLE) {
  1784.                 DRM_DEBUG_KMS("PSR condition failed: Stereo 3D is Enabled\n");
  1785.                 return false;
  1786.         }
  1787.  
  1788.         if (intel_crtc->config.adjusted_mode.flags & DRM_MODE_FLAG_INTERLACE) {
  1789.                 DRM_DEBUG_KMS("PSR condition failed: Interlaced is Enabled\n");
  1790.                 return false;
  1791.         }
  1792.  
  1793.  out:
  1794.         dev_priv->psr.source_ok = true;
  1795.         return true;
  1796. }
  1797.  
  1798. static void intel_edp_psr_do_enable(struct intel_dp *intel_dp)
  1799. {
  1800.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  1801.         struct drm_device *dev = intel_dig_port->base.base.dev;
  1802.         struct drm_i915_private *dev_priv = dev->dev_private;
  1803.  
  1804.         WARN_ON(I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE);
  1805.         WARN_ON(dev_priv->psr.active);
  1806.         lockdep_assert_held(&dev_priv->psr.lock);
  1807.  
  1808.         /* Enable PSR on the panel */
  1809.         intel_edp_psr_enable_sink(intel_dp);
  1810.  
  1811.         /* Enable PSR on the host */
  1812.         intel_edp_psr_enable_source(intel_dp);
  1813.  
  1814.         dev_priv->psr.active = true;
  1815. }
  1816.  
  1817. void intel_edp_psr_enable(struct intel_dp *intel_dp)
  1818. {
  1819.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1820.         struct drm_i915_private *dev_priv = dev->dev_private;
  1821.  
  1822.         if (!HAS_PSR(dev)) {
  1823.                 DRM_DEBUG_KMS("PSR not supported on this platform\n");
  1824.                 return;
  1825.         }
  1826.  
  1827.         if (!is_edp_psr(intel_dp)) {
  1828.                 DRM_DEBUG_KMS("PSR not supported by this panel\n");
  1829.                 return;
  1830.         }
  1831.  
  1832.         mutex_lock(&dev_priv->psr.lock);
  1833.         if (dev_priv->psr.enabled) {
  1834.                 DRM_DEBUG_KMS("PSR already in use\n");
  1835.                 mutex_unlock(&dev_priv->psr.lock);
  1836.                 return;
  1837.         }
  1838.  
  1839.         dev_priv->psr.busy_frontbuffer_bits = 0;
  1840.  
  1841.         /* Setup PSR once */
  1842.         intel_edp_psr_setup(intel_dp);
  1843.  
  1844.         if (intel_edp_psr_match_conditions(intel_dp))
  1845.                 dev_priv->psr.enabled = intel_dp;
  1846.         mutex_unlock(&dev_priv->psr.lock);
  1847. }
  1848.  
  1849. void intel_edp_psr_disable(struct intel_dp *intel_dp)
  1850. {
  1851.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  1852.         struct drm_i915_private *dev_priv = dev->dev_private;
  1853.  
  1854.         mutex_lock(&dev_priv->psr.lock);
  1855.         if (!dev_priv->psr.enabled) {
  1856.                 mutex_unlock(&dev_priv->psr.lock);
  1857.                 return;
  1858.         }
  1859.  
  1860.         if (dev_priv->psr.active) {
  1861.         I915_WRITE(EDP_PSR_CTL(dev),
  1862.                    I915_READ(EDP_PSR_CTL(dev)) & ~EDP_PSR_ENABLE);
  1863.  
  1864.         /* Wait till PSR is idle */
  1865.         if (_wait_for((I915_READ(EDP_PSR_STATUS_CTL(dev)) &
  1866.                        EDP_PSR_STATUS_STATE_MASK) == 0, 2000, 10))
  1867.                 DRM_ERROR("Timed out waiting for PSR Idle State\n");
  1868.  
  1869.                 dev_priv->psr.active = false;
  1870.         } else {
  1871.                 WARN_ON(I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE);
  1872.         }
  1873.  
  1874.         dev_priv->psr.enabled = NULL;
  1875.         mutex_unlock(&dev_priv->psr.lock);
  1876.  
  1877.         cancel_delayed_work_sync(&dev_priv->psr.work);
  1878. }
  1879.  
  1880. static void intel_edp_psr_work(struct work_struct *work)
  1881. {
  1882.         struct drm_i915_private *dev_priv =
  1883.                 container_of(work, typeof(*dev_priv), psr.work.work);
  1884.         struct intel_dp *intel_dp = dev_priv->psr.enabled;
  1885.  
  1886.         mutex_lock(&dev_priv->psr.lock);
  1887.         intel_dp = dev_priv->psr.enabled;
  1888.  
  1889.         if (!intel_dp)
  1890.                 goto unlock;
  1891.  
  1892.         /*
  1893.          * The delayed work can race with an invalidate hence we need to
  1894.          * recheck. Since psr_flush first clears this and then reschedules we
  1895.          * won't ever miss a flush when bailing out here.
  1896.          */
  1897.         if (dev_priv->psr.busy_frontbuffer_bits)
  1898.                 goto unlock;
  1899.  
  1900.         intel_edp_psr_do_enable(intel_dp);
  1901. unlock:
  1902.         mutex_unlock(&dev_priv->psr.lock);
  1903. }
  1904.  
  1905. static void intel_edp_psr_do_exit(struct drm_device *dev)
  1906. {
  1907.         struct drm_i915_private *dev_priv = dev->dev_private;
  1908.  
  1909.         if (dev_priv->psr.active) {
  1910.                 u32 val = I915_READ(EDP_PSR_CTL(dev));
  1911.  
  1912.                 WARN_ON(!(val & EDP_PSR_ENABLE));
  1913.  
  1914.                 I915_WRITE(EDP_PSR_CTL(dev), val & ~EDP_PSR_ENABLE);
  1915.  
  1916.                 dev_priv->psr.active = false;
  1917.         }
  1918.  
  1919. }
  1920.  
  1921. void intel_edp_psr_invalidate(struct drm_device *dev,
  1922.                               unsigned frontbuffer_bits)
  1923. {
  1924.         struct drm_i915_private *dev_priv = dev->dev_private;
  1925.         struct drm_crtc *crtc;
  1926.         enum pipe pipe;
  1927.  
  1928.         mutex_lock(&dev_priv->psr.lock);
  1929.         if (!dev_priv->psr.enabled) {
  1930.                 mutex_unlock(&dev_priv->psr.lock);
  1931.                                 return;
  1932.         }
  1933.  
  1934.         crtc = dp_to_dig_port(dev_priv->psr.enabled)->base.base.crtc;
  1935.         pipe = to_intel_crtc(crtc)->pipe;
  1936.  
  1937.         intel_edp_psr_do_exit(dev);
  1938.  
  1939.         frontbuffer_bits &= INTEL_FRONTBUFFER_ALL_MASK(pipe);
  1940.  
  1941.         dev_priv->psr.busy_frontbuffer_bits |= frontbuffer_bits;
  1942.         mutex_unlock(&dev_priv->psr.lock);
  1943. }
  1944.  
  1945. void intel_edp_psr_flush(struct drm_device *dev,
  1946.                          unsigned frontbuffer_bits)
  1947. {
  1948.         struct drm_i915_private *dev_priv = dev->dev_private;
  1949.         struct drm_crtc *crtc;
  1950.         enum pipe pipe;
  1951.  
  1952.         mutex_lock(&dev_priv->psr.lock);
  1953.         if (!dev_priv->psr.enabled) {
  1954.                 mutex_unlock(&dev_priv->psr.lock);
  1955.                 return;
  1956.                 }
  1957.  
  1958.         crtc = dp_to_dig_port(dev_priv->psr.enabled)->base.base.crtc;
  1959.         pipe = to_intel_crtc(crtc)->pipe;
  1960.         dev_priv->psr.busy_frontbuffer_bits &= ~frontbuffer_bits;
  1961.  
  1962.         /*
  1963.          * On Haswell sprite plane updates don't result in a psr invalidating
  1964.          * signal in the hardware. Which means we need to manually fake this in
  1965.          * software for all flushes, not just when we've seen a preceding
  1966.          * invalidation through frontbuffer rendering.
  1967.          */
  1968.         if (IS_HASWELL(dev) &&
  1969.             (frontbuffer_bits & INTEL_FRONTBUFFER_SPRITE(pipe)))
  1970.                 intel_edp_psr_do_exit(dev);
  1971.  
  1972.         if (!dev_priv->psr.active && !dev_priv->psr.busy_frontbuffer_bits)
  1973.                 schedule_delayed_work(&dev_priv->psr.work,
  1974.                                       msecs_to_jiffies(100));
  1975.         mutex_unlock(&dev_priv->psr.lock);
  1976. }
  1977.  
  1978. void intel_edp_psr_init(struct drm_device *dev)
  1979. {
  1980.         struct drm_i915_private *dev_priv = dev->dev_private;
  1981.  
  1982.         INIT_DELAYED_WORK(&dev_priv->psr.work, intel_edp_psr_work);
  1983.         mutex_init(&dev_priv->psr.lock);
  1984. }
  1985.  
  1986. static void intel_disable_dp(struct intel_encoder *encoder)
  1987. {
  1988.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  1989.         enum port port = dp_to_dig_port(intel_dp)->port;
  1990.         struct drm_device *dev = encoder->base.dev;
  1991.  
  1992.         /* Make sure the panel is off before trying to change the mode. But also
  1993.          * ensure that we have vdd while we switch off the panel. */
  1994.         intel_edp_panel_vdd_on(intel_dp);
  1995.         intel_edp_backlight_off(intel_dp);
  1996.         intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF);
  1997.         intel_edp_panel_off(intel_dp);
  1998.  
  1999.         /* cpu edp my only be disable _after_ the cpu pipe/plane is disabled. */
  2000.         if (!(port == PORT_A || IS_VALLEYVIEW(dev)))
  2001.                 intel_dp_link_down(intel_dp);
  2002. }
  2003.  
  2004. static void g4x_post_disable_dp(struct intel_encoder *encoder)
  2005. {
  2006.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2007.         enum port port = dp_to_dig_port(intel_dp)->port;
  2008.  
  2009.         if (port != PORT_A)
  2010.                 return;
  2011.  
  2012.         intel_dp_link_down(intel_dp);
  2013.         ironlake_edp_pll_off(intel_dp);
  2014. }
  2015.  
  2016. static void vlv_post_disable_dp(struct intel_encoder *encoder)
  2017. {
  2018.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2019.  
  2020.         intel_dp_link_down(intel_dp);
  2021. }
  2022.  
  2023. static void chv_post_disable_dp(struct intel_encoder *encoder)
  2024. {
  2025.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2026.         struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
  2027.         struct drm_device *dev = encoder->base.dev;
  2028.         struct drm_i915_private *dev_priv = dev->dev_private;
  2029.         struct intel_crtc *intel_crtc =
  2030.                 to_intel_crtc(encoder->base.crtc);
  2031.         enum dpio_channel ch = vlv_dport_to_channel(dport);
  2032.         enum pipe pipe = intel_crtc->pipe;
  2033.         u32 val;
  2034.  
  2035.                 intel_dp_link_down(intel_dp);
  2036.  
  2037.         mutex_lock(&dev_priv->dpio_lock);
  2038.  
  2039.         /* Propagate soft reset to data lane reset */
  2040.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW1(ch));
  2041.         val |= CHV_PCS_REQ_SOFTRESET_EN;
  2042.         vlv_dpio_write(dev_priv, pipe, VLV_PCS01_DW1(ch), val);
  2043.  
  2044.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS23_DW1(ch));
  2045.         val |= CHV_PCS_REQ_SOFTRESET_EN;
  2046.         vlv_dpio_write(dev_priv, pipe, VLV_PCS23_DW1(ch), val);
  2047.  
  2048.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW0(ch));
  2049.         val &= ~(DPIO_PCS_TX_LANE2_RESET | DPIO_PCS_TX_LANE1_RESET);
  2050.         vlv_dpio_write(dev_priv, pipe, VLV_PCS01_DW0(ch), val);
  2051.  
  2052.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS23_DW0(ch));
  2053.         val &= ~(DPIO_PCS_TX_LANE2_RESET | DPIO_PCS_TX_LANE1_RESET);
  2054.         vlv_dpio_write(dev_priv, pipe, VLV_PCS23_DW0(ch), val);
  2055.  
  2056.         mutex_unlock(&dev_priv->dpio_lock);
  2057. }
  2058.  
  2059. static void intel_enable_dp(struct intel_encoder *encoder)
  2060. {
  2061.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2062.         struct drm_device *dev = encoder->base.dev;
  2063.         struct drm_i915_private *dev_priv = dev->dev_private;
  2064.         uint32_t dp_reg = I915_READ(intel_dp->output_reg);
  2065.  
  2066.         if (WARN_ON(dp_reg & DP_PORT_EN))
  2067.                 return;
  2068.  
  2069.         intel_edp_panel_vdd_on(intel_dp);
  2070.         intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
  2071.                         intel_dp_start_link_train(intel_dp);
  2072.         intel_edp_panel_on(intel_dp);
  2073.         edp_panel_vdd_off(intel_dp, true);
  2074.                         intel_dp_complete_link_train(intel_dp);
  2075.         intel_dp_stop_link_train(intel_dp);
  2076. }
  2077.  
  2078. static void g4x_enable_dp(struct intel_encoder *encoder)
  2079. {
  2080.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2081.  
  2082.         intel_enable_dp(encoder);
  2083.         intel_edp_backlight_on(intel_dp);
  2084. }
  2085.  
  2086. static void vlv_enable_dp(struct intel_encoder *encoder)
  2087. {
  2088.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2089.  
  2090.         intel_edp_backlight_on(intel_dp);
  2091. }
  2092.  
  2093. static void g4x_pre_enable_dp(struct intel_encoder *encoder)
  2094. {
  2095.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2096.         struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
  2097.  
  2098.         intel_dp_prepare(encoder);
  2099.  
  2100.         /* Only ilk+ has port A */
  2101.         if (dport->port == PORT_A) {
  2102.                 ironlake_set_pll_cpu_edp(intel_dp);
  2103.                 ironlake_edp_pll_on(intel_dp);
  2104.         }
  2105. }
  2106.  
  2107. static void vlv_pre_enable_dp(struct intel_encoder *encoder)
  2108. {
  2109.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2110.         struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
  2111.         struct drm_device *dev = encoder->base.dev;
  2112.         struct drm_i915_private *dev_priv = dev->dev_private;
  2113.         struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
  2114.         enum dpio_channel port = vlv_dport_to_channel(dport);
  2115.                 int pipe = intel_crtc->pipe;
  2116.         struct edp_power_seq power_seq;
  2117.                 u32 val;
  2118.  
  2119.         mutex_lock(&dev_priv->dpio_lock);
  2120.  
  2121.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(port));
  2122.                 val = 0;
  2123.                 if (pipe)
  2124.                         val |= (1<<21);
  2125.                 else
  2126.                         val &= ~(1<<21);
  2127.                 val |= 0x001000c4;
  2128.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW8(port), val);
  2129.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW14(port), 0x00760018);
  2130.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW23(port), 0x00400888);
  2131.  
  2132.         mutex_unlock(&dev_priv->dpio_lock);
  2133.  
  2134.         if (is_edp(intel_dp)) {
  2135.         /* init power sequencer on this pipe and port */
  2136.         intel_dp_init_panel_power_sequencer(dev, intel_dp, &power_seq);
  2137.         intel_dp_init_panel_power_sequencer_registers(dev, intel_dp,
  2138.                                                       &power_seq);
  2139.         }
  2140.  
  2141.         intel_enable_dp(encoder);
  2142.  
  2143.         vlv_wait_port_ready(dev_priv, dport);
  2144. }
  2145.  
  2146. static void vlv_dp_pre_pll_enable(struct intel_encoder *encoder)
  2147. {
  2148.         struct intel_digital_port *dport = enc_to_dig_port(&encoder->base);
  2149.         struct drm_device *dev = encoder->base.dev;
  2150.         struct drm_i915_private *dev_priv = dev->dev_private;
  2151.         struct intel_crtc *intel_crtc =
  2152.                 to_intel_crtc(encoder->base.crtc);
  2153.         enum dpio_channel port = vlv_dport_to_channel(dport);
  2154.         int pipe = intel_crtc->pipe;
  2155.  
  2156.         intel_dp_prepare(encoder);
  2157.  
  2158.         /* Program Tx lane resets to default */
  2159.         mutex_lock(&dev_priv->dpio_lock);
  2160.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW0(port),
  2161.                          DPIO_PCS_TX_LANE2_RESET |
  2162.                          DPIO_PCS_TX_LANE1_RESET);
  2163.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW1(port),
  2164.                          DPIO_PCS_CLK_CRI_RXEB_EIOS_EN |
  2165.                          DPIO_PCS_CLK_CRI_RXDIGFILTSG_EN |
  2166.                          (1<<DPIO_PCS_CLK_DATAWIDTH_SHIFT) |
  2167.                                  DPIO_PCS_CLK_SOFT_RESET);
  2168.  
  2169.         /* Fix up inter-pair skew failure */
  2170.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW12(port), 0x00750f00);
  2171.         vlv_dpio_write(dev_priv, pipe, VLV_TX_DW11(port), 0x00001500);
  2172.         vlv_dpio_write(dev_priv, pipe, VLV_TX_DW14(port), 0x40400000);
  2173.         mutex_unlock(&dev_priv->dpio_lock);
  2174. }
  2175.  
  2176. static void chv_pre_enable_dp(struct intel_encoder *encoder)
  2177. {
  2178.         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
  2179.         struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
  2180.         struct drm_device *dev = encoder->base.dev;
  2181.         struct drm_i915_private *dev_priv = dev->dev_private;
  2182.         struct edp_power_seq power_seq;
  2183.         struct intel_crtc *intel_crtc =
  2184.                 to_intel_crtc(encoder->base.crtc);
  2185.         enum dpio_channel ch = vlv_dport_to_channel(dport);
  2186.         int pipe = intel_crtc->pipe;
  2187.         int data, i;
  2188.         u32 val;
  2189.  
  2190.         mutex_lock(&dev_priv->dpio_lock);
  2191.  
  2192.         /* Deassert soft data lane reset*/
  2193.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW1(ch));
  2194.         val |= CHV_PCS_REQ_SOFTRESET_EN;
  2195.         vlv_dpio_write(dev_priv, pipe, VLV_PCS01_DW1(ch), val);
  2196.  
  2197.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS23_DW1(ch));
  2198.         val |= CHV_PCS_REQ_SOFTRESET_EN;
  2199.         vlv_dpio_write(dev_priv, pipe, VLV_PCS23_DW1(ch), val);
  2200.  
  2201.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW0(ch));
  2202.         val |= (DPIO_PCS_TX_LANE2_RESET | DPIO_PCS_TX_LANE1_RESET);
  2203.         vlv_dpio_write(dev_priv, pipe, VLV_PCS01_DW0(ch), val);
  2204.  
  2205.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS23_DW0(ch));
  2206.         val |= (DPIO_PCS_TX_LANE2_RESET | DPIO_PCS_TX_LANE1_RESET);
  2207.         vlv_dpio_write(dev_priv, pipe, VLV_PCS23_DW0(ch), val);
  2208.  
  2209.         /* Program Tx lane latency optimal setting*/
  2210.         for (i = 0; i < 4; i++) {
  2211.                 /* Set the latency optimal bit */
  2212.                 data = (i == 1) ? 0x0 : 0x6;
  2213.                 vlv_dpio_write(dev_priv, pipe, CHV_TX_DW11(ch, i),
  2214.                                 data << DPIO_FRC_LATENCY_SHFIT);
  2215.  
  2216.                 /* Set the upar bit */
  2217.                 data = (i == 1) ? 0x0 : 0x1;
  2218.                 vlv_dpio_write(dev_priv, pipe, CHV_TX_DW14(ch, i),
  2219.                                 data << DPIO_UPAR_SHIFT);
  2220.         }
  2221.  
  2222.         /* Data lane stagger programming */
  2223.         /* FIXME: Fix up value only after power analysis */
  2224.  
  2225.         mutex_unlock(&dev_priv->dpio_lock);
  2226.  
  2227.         if (is_edp(intel_dp)) {
  2228.                 /* init power sequencer on this pipe and port */
  2229.                 intel_dp_init_panel_power_sequencer(dev, intel_dp, &power_seq);
  2230.                 intel_dp_init_panel_power_sequencer_registers(dev, intel_dp,
  2231.                                                               &power_seq);
  2232.         }
  2233.  
  2234.         intel_enable_dp(encoder);
  2235.  
  2236.         vlv_wait_port_ready(dev_priv, dport);
  2237. }
  2238.  
  2239. static void chv_dp_pre_pll_enable(struct intel_encoder *encoder)
  2240. {
  2241.         struct intel_digital_port *dport = enc_to_dig_port(&encoder->base);
  2242.         struct drm_device *dev = encoder->base.dev;
  2243.         struct drm_i915_private *dev_priv = dev->dev_private;
  2244.         struct intel_crtc *intel_crtc =
  2245.                 to_intel_crtc(encoder->base.crtc);
  2246.         enum dpio_channel ch = vlv_dport_to_channel(dport);
  2247.         enum pipe pipe = intel_crtc->pipe;
  2248.         u32 val;
  2249.  
  2250.         mutex_lock(&dev_priv->dpio_lock);
  2251.  
  2252.         /* program left/right clock distribution */
  2253.         if (pipe != PIPE_B) {
  2254.                 val = vlv_dpio_read(dev_priv, pipe, _CHV_CMN_DW5_CH0);
  2255.                 val &= ~(CHV_BUFLEFTENA1_MASK | CHV_BUFRIGHTENA1_MASK);
  2256.                 if (ch == DPIO_CH0)
  2257.                         val |= CHV_BUFLEFTENA1_FORCE;
  2258.                 if (ch == DPIO_CH1)
  2259.                         val |= CHV_BUFRIGHTENA1_FORCE;
  2260.                 vlv_dpio_write(dev_priv, pipe, _CHV_CMN_DW5_CH0, val);
  2261.         } else {
  2262.                 val = vlv_dpio_read(dev_priv, pipe, _CHV_CMN_DW1_CH1);
  2263.                 val &= ~(CHV_BUFLEFTENA2_MASK | CHV_BUFRIGHTENA2_MASK);
  2264.                 if (ch == DPIO_CH0)
  2265.                         val |= CHV_BUFLEFTENA2_FORCE;
  2266.                 if (ch == DPIO_CH1)
  2267.                         val |= CHV_BUFRIGHTENA2_FORCE;
  2268.                 vlv_dpio_write(dev_priv, pipe, _CHV_CMN_DW1_CH1, val);
  2269.         }
  2270.  
  2271.         /* program clock channel usage */
  2272.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(ch));
  2273.         val |= CHV_PCS_USEDCLKCHANNEL_OVRRIDE;
  2274.         if (pipe != PIPE_B)
  2275.                 val &= ~CHV_PCS_USEDCLKCHANNEL;
  2276.         else
  2277.                 val |= CHV_PCS_USEDCLKCHANNEL;
  2278.         vlv_dpio_write(dev_priv, pipe, VLV_PCS01_DW8(ch), val);
  2279.  
  2280.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS23_DW8(ch));
  2281.         val |= CHV_PCS_USEDCLKCHANNEL_OVRRIDE;
  2282.         if (pipe != PIPE_B)
  2283.                 val &= ~CHV_PCS_USEDCLKCHANNEL;
  2284.         else
  2285.                 val |= CHV_PCS_USEDCLKCHANNEL;
  2286.         vlv_dpio_write(dev_priv, pipe, VLV_PCS23_DW8(ch), val);
  2287.  
  2288.         /*
  2289.          * This a a bit weird since generally CL
  2290.          * matches the pipe, but here we need to
  2291.          * pick the CL based on the port.
  2292.          */
  2293.         val = vlv_dpio_read(dev_priv, pipe, CHV_CMN_DW19(ch));
  2294.         if (pipe != PIPE_B)
  2295.                 val &= ~CHV_CMN_USEDCLKCHANNEL;
  2296.         else
  2297.                 val |= CHV_CMN_USEDCLKCHANNEL;
  2298.         vlv_dpio_write(dev_priv, pipe, CHV_CMN_DW19(ch), val);
  2299.  
  2300.         mutex_unlock(&dev_priv->dpio_lock);
  2301. }
  2302.  
  2303. /*
  2304.  * Native read with retry for link status and receiver capability reads for
  2305.  * cases where the sink may still be asleep.
  2306.  *
  2307.  * Sinks are *supposed* to come up within 1ms from an off state, but we're also
  2308.  * supposed to retry 3 times per the spec.
  2309.  */
  2310. static ssize_t
  2311. intel_dp_dpcd_read_wake(struct drm_dp_aux *aux, unsigned int offset,
  2312.                         void *buffer, size_t size)
  2313. {
  2314.         ssize_t ret;
  2315.         int i;
  2316.  
  2317.         for (i = 0; i < 3; i++) {
  2318.                 ret = drm_dp_dpcd_read(aux, offset, buffer, size);
  2319.                 if (ret == size)
  2320.                         return ret;
  2321.                 msleep(1);
  2322.         }
  2323.  
  2324.         return ret;
  2325. }
  2326.  
  2327. /*
  2328.  * Fetch AUX CH registers 0x202 - 0x207 which contain
  2329.  * link status information
  2330.  */
  2331. static bool
  2332. intel_dp_get_link_status(struct intel_dp *intel_dp, uint8_t link_status[DP_LINK_STATUS_SIZE])
  2333. {
  2334.         return intel_dp_dpcd_read_wake(&intel_dp->aux,
  2335.                                               DP_LANE0_1_STATUS,
  2336.                                               link_status,
  2337.                                        DP_LINK_STATUS_SIZE) == DP_LINK_STATUS_SIZE;
  2338. }
  2339.  
  2340. /* These are source-specific values. */
  2341. static uint8_t
  2342. intel_dp_voltage_max(struct intel_dp *intel_dp)
  2343. {
  2344.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  2345.         enum port port = dp_to_dig_port(intel_dp)->port;
  2346.  
  2347.         if (IS_VALLEYVIEW(dev))
  2348.                 return DP_TRAIN_VOLTAGE_SWING_1200;
  2349.         else if (IS_GEN7(dev) && port == PORT_A)
  2350.                 return DP_TRAIN_VOLTAGE_SWING_800;
  2351.         else if (HAS_PCH_CPT(dev) && port != PORT_A)
  2352.                 return DP_TRAIN_VOLTAGE_SWING_1200;
  2353.         else
  2354.                 return DP_TRAIN_VOLTAGE_SWING_800;
  2355. }
  2356.  
  2357. static uint8_t
  2358. intel_dp_pre_emphasis_max(struct intel_dp *intel_dp, uint8_t voltage_swing)
  2359. {
  2360.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  2361.         enum port port = dp_to_dig_port(intel_dp)->port;
  2362.  
  2363.         if (IS_HASWELL(dev) || IS_BROADWELL(dev)) {
  2364.                 switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2365.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2366.                         return DP_TRAIN_PRE_EMPHASIS_9_5;
  2367.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2368.                         return DP_TRAIN_PRE_EMPHASIS_6;
  2369.                 case DP_TRAIN_VOLTAGE_SWING_800:
  2370.                         return DP_TRAIN_PRE_EMPHASIS_3_5;
  2371.                 case DP_TRAIN_VOLTAGE_SWING_1200:
  2372.                 default:
  2373.                         return DP_TRAIN_PRE_EMPHASIS_0;
  2374.                 }
  2375.         } else if (IS_VALLEYVIEW(dev)) {
  2376.                 switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2377.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2378.                         return DP_TRAIN_PRE_EMPHASIS_9_5;
  2379.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2380.                         return DP_TRAIN_PRE_EMPHASIS_6;
  2381.                 case DP_TRAIN_VOLTAGE_SWING_800:
  2382.                         return DP_TRAIN_PRE_EMPHASIS_3_5;
  2383.                 case DP_TRAIN_VOLTAGE_SWING_1200:
  2384.                 default:
  2385.                         return DP_TRAIN_PRE_EMPHASIS_0;
  2386.                 }
  2387.         } else if (IS_GEN7(dev) && port == PORT_A) {
  2388.                 switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2389.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2390.                         return DP_TRAIN_PRE_EMPHASIS_6;
  2391.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2392.                 case DP_TRAIN_VOLTAGE_SWING_800:
  2393.                         return DP_TRAIN_PRE_EMPHASIS_3_5;
  2394.                 default:
  2395.                         return DP_TRAIN_PRE_EMPHASIS_0;
  2396.                 }
  2397.         } else {
  2398.         switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2399.         case DP_TRAIN_VOLTAGE_SWING_400:
  2400.                 return DP_TRAIN_PRE_EMPHASIS_6;
  2401.         case DP_TRAIN_VOLTAGE_SWING_600:
  2402.                 return DP_TRAIN_PRE_EMPHASIS_6;
  2403.         case DP_TRAIN_VOLTAGE_SWING_800:
  2404.                 return DP_TRAIN_PRE_EMPHASIS_3_5;
  2405.         case DP_TRAIN_VOLTAGE_SWING_1200:
  2406.         default:
  2407.                 return DP_TRAIN_PRE_EMPHASIS_0;
  2408.         }
  2409.         }
  2410. }
  2411.  
  2412. static uint32_t intel_vlv_signal_levels(struct intel_dp *intel_dp)
  2413. {
  2414.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  2415.         struct drm_i915_private *dev_priv = dev->dev_private;
  2416.         struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
  2417.         struct intel_crtc *intel_crtc =
  2418.                 to_intel_crtc(dport->base.base.crtc);
  2419.         unsigned long demph_reg_value, preemph_reg_value,
  2420.                 uniqtranscale_reg_value;
  2421.         uint8_t train_set = intel_dp->train_set[0];
  2422.         enum dpio_channel port = vlv_dport_to_channel(dport);
  2423.         int pipe = intel_crtc->pipe;
  2424.  
  2425.         switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
  2426.         case DP_TRAIN_PRE_EMPHASIS_0:
  2427.                 preemph_reg_value = 0x0004000;
  2428.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2429.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2430.                         demph_reg_value = 0x2B405555;
  2431.                         uniqtranscale_reg_value = 0x552AB83A;
  2432.                         break;
  2433.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2434.                         demph_reg_value = 0x2B404040;
  2435.                         uniqtranscale_reg_value = 0x5548B83A;
  2436.                         break;
  2437.                 case DP_TRAIN_VOLTAGE_SWING_800:
  2438.                         demph_reg_value = 0x2B245555;
  2439.                         uniqtranscale_reg_value = 0x5560B83A;
  2440.                         break;
  2441.                 case DP_TRAIN_VOLTAGE_SWING_1200:
  2442.                         demph_reg_value = 0x2B405555;
  2443.                         uniqtranscale_reg_value = 0x5598DA3A;
  2444.                         break;
  2445.                 default:
  2446.                         return 0;
  2447.                 }
  2448.                 break;
  2449.         case DP_TRAIN_PRE_EMPHASIS_3_5:
  2450.                 preemph_reg_value = 0x0002000;
  2451.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2452.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2453.                         demph_reg_value = 0x2B404040;
  2454.                         uniqtranscale_reg_value = 0x5552B83A;
  2455.                         break;
  2456.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2457.                         demph_reg_value = 0x2B404848;
  2458.                         uniqtranscale_reg_value = 0x5580B83A;
  2459.                         break;
  2460.                 case DP_TRAIN_VOLTAGE_SWING_800:
  2461.                         demph_reg_value = 0x2B404040;
  2462.                         uniqtranscale_reg_value = 0x55ADDA3A;
  2463.                         break;
  2464.                 default:
  2465.                         return 0;
  2466.                 }
  2467.                 break;
  2468.         case DP_TRAIN_PRE_EMPHASIS_6:
  2469.                 preemph_reg_value = 0x0000000;
  2470.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2471.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2472.                         demph_reg_value = 0x2B305555;
  2473.                         uniqtranscale_reg_value = 0x5570B83A;
  2474.                         break;
  2475.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2476.                         demph_reg_value = 0x2B2B4040;
  2477.                         uniqtranscale_reg_value = 0x55ADDA3A;
  2478.                         break;
  2479.                 default:
  2480.                         return 0;
  2481.                 }
  2482.                 break;
  2483.         case DP_TRAIN_PRE_EMPHASIS_9_5:
  2484.                 preemph_reg_value = 0x0006000;
  2485.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2486.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2487.                         demph_reg_value = 0x1B405555;
  2488.                         uniqtranscale_reg_value = 0x55ADDA3A;
  2489.                         break;
  2490.                 default:
  2491.                         return 0;
  2492.                 }
  2493.                 break;
  2494.         default:
  2495.                 return 0;
  2496.         }
  2497.  
  2498.         mutex_lock(&dev_priv->dpio_lock);
  2499.         vlv_dpio_write(dev_priv, pipe, VLV_TX_DW5(port), 0x00000000);
  2500.         vlv_dpio_write(dev_priv, pipe, VLV_TX_DW4(port), demph_reg_value);
  2501.         vlv_dpio_write(dev_priv, pipe, VLV_TX_DW2(port),
  2502.                          uniqtranscale_reg_value);
  2503.         vlv_dpio_write(dev_priv, pipe, VLV_TX_DW3(port), 0x0C782040);
  2504.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW11(port), 0x00030000);
  2505.         vlv_dpio_write(dev_priv, pipe, VLV_PCS_DW9(port), preemph_reg_value);
  2506.         vlv_dpio_write(dev_priv, pipe, VLV_TX_DW5(port), 0x80000000);
  2507.         mutex_unlock(&dev_priv->dpio_lock);
  2508.  
  2509.         return 0;
  2510. }
  2511.  
  2512. static uint32_t intel_chv_signal_levels(struct intel_dp *intel_dp)
  2513. {
  2514.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  2515.         struct drm_i915_private *dev_priv = dev->dev_private;
  2516.         struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
  2517.         struct intel_crtc *intel_crtc = to_intel_crtc(dport->base.base.crtc);
  2518.         u32 deemph_reg_value, margin_reg_value, val;
  2519.         uint8_t train_set = intel_dp->train_set[0];
  2520.         enum dpio_channel ch = vlv_dport_to_channel(dport);
  2521.         enum pipe pipe = intel_crtc->pipe;
  2522.         int i;
  2523.  
  2524.         switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
  2525.         case DP_TRAIN_PRE_EMPHASIS_0:
  2526.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2527.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2528.                         deemph_reg_value = 128;
  2529.                         margin_reg_value = 52;
  2530.                         break;
  2531.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2532.                         deemph_reg_value = 128;
  2533.                         margin_reg_value = 77;
  2534.                         break;
  2535.                 case DP_TRAIN_VOLTAGE_SWING_800:
  2536.                         deemph_reg_value = 128;
  2537.                         margin_reg_value = 102;
  2538.                         break;
  2539.                 case DP_TRAIN_VOLTAGE_SWING_1200:
  2540.                         deemph_reg_value = 128;
  2541.                         margin_reg_value = 154;
  2542.                         /* FIXME extra to set for 1200 */
  2543.                         break;
  2544.                 default:
  2545.                         return 0;
  2546.                 }
  2547.                 break;
  2548.         case DP_TRAIN_PRE_EMPHASIS_3_5:
  2549.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2550.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2551.                         deemph_reg_value = 85;
  2552.                         margin_reg_value = 78;
  2553.                         break;
  2554.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2555.                         deemph_reg_value = 85;
  2556.                         margin_reg_value = 116;
  2557.                         break;
  2558.                 case DP_TRAIN_VOLTAGE_SWING_800:
  2559.                         deemph_reg_value = 85;
  2560.                         margin_reg_value = 154;
  2561.                         break;
  2562.                 default:
  2563.                         return 0;
  2564.                 }
  2565.                 break;
  2566.         case DP_TRAIN_PRE_EMPHASIS_6:
  2567.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2568.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2569.                         deemph_reg_value = 64;
  2570.                         margin_reg_value = 104;
  2571.                         break;
  2572.                 case DP_TRAIN_VOLTAGE_SWING_600:
  2573.                         deemph_reg_value = 64;
  2574.                         margin_reg_value = 154;
  2575.                         break;
  2576.                 default:
  2577.                         return 0;
  2578.                 }
  2579.                 break;
  2580.         case DP_TRAIN_PRE_EMPHASIS_9_5:
  2581.                 switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2582.                 case DP_TRAIN_VOLTAGE_SWING_400:
  2583.                         deemph_reg_value = 43;
  2584.                         margin_reg_value = 154;
  2585.                         break;
  2586.                 default:
  2587.                         return 0;
  2588.                 }
  2589.                 break;
  2590.         default:
  2591.                 return 0;
  2592.         }
  2593.  
  2594.         mutex_lock(&dev_priv->dpio_lock);
  2595.  
  2596.         /* Clear calc init */
  2597.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW10(ch));
  2598.         val &= ~(DPIO_PCS_SWING_CALC_TX0_TX2 | DPIO_PCS_SWING_CALC_TX1_TX3);
  2599.         vlv_dpio_write(dev_priv, pipe, VLV_PCS01_DW10(ch), val);
  2600.  
  2601.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS23_DW10(ch));
  2602.         val &= ~(DPIO_PCS_SWING_CALC_TX0_TX2 | DPIO_PCS_SWING_CALC_TX1_TX3);
  2603.         vlv_dpio_write(dev_priv, pipe, VLV_PCS23_DW10(ch), val);
  2604.  
  2605.         /* Program swing deemph */
  2606.         for (i = 0; i < 4; i++) {
  2607.                 val = vlv_dpio_read(dev_priv, pipe, CHV_TX_DW4(ch, i));
  2608.                 val &= ~DPIO_SWING_DEEMPH9P5_MASK;
  2609.                 val |= deemph_reg_value << DPIO_SWING_DEEMPH9P5_SHIFT;
  2610.                 vlv_dpio_write(dev_priv, pipe, CHV_TX_DW4(ch, i), val);
  2611.         }
  2612.  
  2613.         /* Program swing margin */
  2614.         for (i = 0; i < 4; i++) {
  2615.                 val = vlv_dpio_read(dev_priv, pipe, CHV_TX_DW2(ch, i));
  2616.                 val &= ~DPIO_SWING_MARGIN_MASK;
  2617.                 val |= margin_reg_value << DPIO_SWING_MARGIN_SHIFT;
  2618.                 vlv_dpio_write(dev_priv, pipe, CHV_TX_DW2(ch, i), val);
  2619.         }
  2620.  
  2621.         /* Disable unique transition scale */
  2622.         for (i = 0; i < 4; i++) {
  2623.                 val = vlv_dpio_read(dev_priv, pipe, CHV_TX_DW3(ch, i));
  2624.                 val &= ~DPIO_TX_UNIQ_TRANS_SCALE_EN;
  2625.                 vlv_dpio_write(dev_priv, pipe, CHV_TX_DW3(ch, i), val);
  2626.         }
  2627.  
  2628.         if (((train_set & DP_TRAIN_PRE_EMPHASIS_MASK)
  2629.                         == DP_TRAIN_PRE_EMPHASIS_0) &&
  2630.                 ((train_set & DP_TRAIN_VOLTAGE_SWING_MASK)
  2631.                         == DP_TRAIN_VOLTAGE_SWING_1200)) {
  2632.  
  2633.                 /*
  2634.                  * The document said it needs to set bit 27 for ch0 and bit 26
  2635.                  * for ch1. Might be a typo in the doc.
  2636.                  * For now, for this unique transition scale selection, set bit
  2637.                  * 27 for ch0 and ch1.
  2638.                  */
  2639.                 for (i = 0; i < 4; i++) {
  2640.                         val = vlv_dpio_read(dev_priv, pipe, CHV_TX_DW3(ch, i));
  2641.                         val |= DPIO_TX_UNIQ_TRANS_SCALE_EN;
  2642.                         vlv_dpio_write(dev_priv, pipe, CHV_TX_DW3(ch, i), val);
  2643.                 }
  2644.  
  2645.                 for (i = 0; i < 4; i++) {
  2646.                         val = vlv_dpio_read(dev_priv, pipe, CHV_TX_DW2(ch, i));
  2647.                         val &= ~(0xff << DPIO_UNIQ_TRANS_SCALE_SHIFT);
  2648.                         val |= (0x9a << DPIO_UNIQ_TRANS_SCALE_SHIFT);
  2649.                         vlv_dpio_write(dev_priv, pipe, CHV_TX_DW2(ch, i), val);
  2650.                 }
  2651.         }
  2652.  
  2653.         /* Start swing calculation */
  2654.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW10(ch));
  2655.         val |= DPIO_PCS_SWING_CALC_TX0_TX2 | DPIO_PCS_SWING_CALC_TX1_TX3;
  2656.         vlv_dpio_write(dev_priv, pipe, VLV_PCS01_DW10(ch), val);
  2657.  
  2658.         val = vlv_dpio_read(dev_priv, pipe, VLV_PCS23_DW10(ch));
  2659.         val |= DPIO_PCS_SWING_CALC_TX0_TX2 | DPIO_PCS_SWING_CALC_TX1_TX3;
  2660.         vlv_dpio_write(dev_priv, pipe, VLV_PCS23_DW10(ch), val);
  2661.  
  2662.         /* LRC Bypass */
  2663.         val = vlv_dpio_read(dev_priv, pipe, CHV_CMN_DW30);
  2664.         val |= DPIO_LRC_BYPASS;
  2665.         vlv_dpio_write(dev_priv, pipe, CHV_CMN_DW30, val);
  2666.  
  2667.         mutex_unlock(&dev_priv->dpio_lock);
  2668.  
  2669.         return 0;
  2670. }
  2671.  
  2672. static void
  2673. intel_get_adjust_train(struct intel_dp *intel_dp,
  2674.                        const uint8_t link_status[DP_LINK_STATUS_SIZE])
  2675. {
  2676.         uint8_t v = 0;
  2677.         uint8_t p = 0;
  2678.         int lane;
  2679.         uint8_t voltage_max;
  2680.         uint8_t preemph_max;
  2681.  
  2682.         for (lane = 0; lane < intel_dp->lane_count; lane++) {
  2683.                 uint8_t this_v = drm_dp_get_adjust_request_voltage(link_status, lane);
  2684.                 uint8_t this_p = drm_dp_get_adjust_request_pre_emphasis(link_status, lane);
  2685.  
  2686.                 if (this_v > v)
  2687.                         v = this_v;
  2688.                 if (this_p > p)
  2689.                         p = this_p;
  2690.         }
  2691.  
  2692.         voltage_max = intel_dp_voltage_max(intel_dp);
  2693.         if (v >= voltage_max)
  2694.                 v = voltage_max | DP_TRAIN_MAX_SWING_REACHED;
  2695.  
  2696.         preemph_max = intel_dp_pre_emphasis_max(intel_dp, v);
  2697.         if (p >= preemph_max)
  2698.                 p = preemph_max | DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
  2699.  
  2700.         for (lane = 0; lane < 4; lane++)
  2701.                 intel_dp->train_set[lane] = v | p;
  2702. }
  2703.  
  2704. static uint32_t
  2705. intel_gen4_signal_levels(uint8_t train_set)
  2706. {
  2707.         uint32_t        signal_levels = 0;
  2708.  
  2709.         switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
  2710.         case DP_TRAIN_VOLTAGE_SWING_400:
  2711.         default:
  2712.                 signal_levels |= DP_VOLTAGE_0_4;
  2713.                 break;
  2714.         case DP_TRAIN_VOLTAGE_SWING_600:
  2715.                 signal_levels |= DP_VOLTAGE_0_6;
  2716.                 break;
  2717.         case DP_TRAIN_VOLTAGE_SWING_800:
  2718.                 signal_levels |= DP_VOLTAGE_0_8;
  2719.                 break;
  2720.         case DP_TRAIN_VOLTAGE_SWING_1200:
  2721.                 signal_levels |= DP_VOLTAGE_1_2;
  2722.                 break;
  2723.         }
  2724.         switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
  2725.         case DP_TRAIN_PRE_EMPHASIS_0:
  2726.         default:
  2727.                 signal_levels |= DP_PRE_EMPHASIS_0;
  2728.                 break;
  2729.         case DP_TRAIN_PRE_EMPHASIS_3_5:
  2730.                 signal_levels |= DP_PRE_EMPHASIS_3_5;
  2731.                 break;
  2732.         case DP_TRAIN_PRE_EMPHASIS_6:
  2733.                 signal_levels |= DP_PRE_EMPHASIS_6;
  2734.                 break;
  2735.         case DP_TRAIN_PRE_EMPHASIS_9_5:
  2736.                 signal_levels |= DP_PRE_EMPHASIS_9_5;
  2737.                 break;
  2738.         }
  2739.         return signal_levels;
  2740. }
  2741.  
  2742. /* Gen6's DP voltage swing and pre-emphasis control */
  2743. static uint32_t
  2744. intel_gen6_edp_signal_levels(uint8_t train_set)
  2745. {
  2746.         int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
  2747.                                          DP_TRAIN_PRE_EMPHASIS_MASK);
  2748.         switch (signal_levels) {
  2749.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_0:
  2750.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_0:
  2751.                 return EDP_LINK_TRAIN_400_600MV_0DB_SNB_B;
  2752.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2753.                 return EDP_LINK_TRAIN_400MV_3_5DB_SNB_B;
  2754.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_6:
  2755.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_6:
  2756.                 return EDP_LINK_TRAIN_400_600MV_6DB_SNB_B;
  2757.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2758.         case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2759.                 return EDP_LINK_TRAIN_600_800MV_3_5DB_SNB_B;
  2760.         case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_0:
  2761.         case DP_TRAIN_VOLTAGE_SWING_1200 | DP_TRAIN_PRE_EMPHASIS_0:
  2762.                 return EDP_LINK_TRAIN_800_1200MV_0DB_SNB_B;
  2763.         default:
  2764.                 DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level:"
  2765.                               "0x%x\n", signal_levels);
  2766.                 return EDP_LINK_TRAIN_400_600MV_0DB_SNB_B;
  2767.         }
  2768. }
  2769.  
  2770. /* Gen7's DP voltage swing and pre-emphasis control */
  2771. static uint32_t
  2772. intel_gen7_edp_signal_levels(uint8_t train_set)
  2773. {
  2774.         int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
  2775.                                          DP_TRAIN_PRE_EMPHASIS_MASK);
  2776.         switch (signal_levels) {
  2777.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_0:
  2778.                 return EDP_LINK_TRAIN_400MV_0DB_IVB;
  2779.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2780.                 return EDP_LINK_TRAIN_400MV_3_5DB_IVB;
  2781.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_6:
  2782.                 return EDP_LINK_TRAIN_400MV_6DB_IVB;
  2783.  
  2784.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_0:
  2785.                 return EDP_LINK_TRAIN_600MV_0DB_IVB;
  2786.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2787.                 return EDP_LINK_TRAIN_600MV_3_5DB_IVB;
  2788.  
  2789.         case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_0:
  2790.                 return EDP_LINK_TRAIN_800MV_0DB_IVB;
  2791.         case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2792.                 return EDP_LINK_TRAIN_800MV_3_5DB_IVB;
  2793.  
  2794.         default:
  2795.                 DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level:"
  2796.                               "0x%x\n", signal_levels);
  2797.                 return EDP_LINK_TRAIN_500MV_0DB_IVB;
  2798.         }
  2799. }
  2800.  
  2801. /* Gen7.5's (HSW) DP voltage swing and pre-emphasis control */
  2802. static uint32_t
  2803. intel_hsw_signal_levels(uint8_t train_set)
  2804. {
  2805.         int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
  2806.                                          DP_TRAIN_PRE_EMPHASIS_MASK);
  2807.         switch (signal_levels) {
  2808.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_0:
  2809.                 return DDI_BUF_EMP_400MV_0DB_HSW;
  2810.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2811.                 return DDI_BUF_EMP_400MV_3_5DB_HSW;
  2812.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_6:
  2813.                 return DDI_BUF_EMP_400MV_6DB_HSW;
  2814.         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_9_5:
  2815.                 return DDI_BUF_EMP_400MV_9_5DB_HSW;
  2816.  
  2817.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_0:
  2818.                 return DDI_BUF_EMP_600MV_0DB_HSW;
  2819.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2820.                 return DDI_BUF_EMP_600MV_3_5DB_HSW;
  2821.         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_6:
  2822.                 return DDI_BUF_EMP_600MV_6DB_HSW;
  2823.  
  2824.         case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_0:
  2825.                 return DDI_BUF_EMP_800MV_0DB_HSW;
  2826.         case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_3_5:
  2827.                 return DDI_BUF_EMP_800MV_3_5DB_HSW;
  2828.         default:
  2829.                 DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level:"
  2830.                               "0x%x\n", signal_levels);
  2831.                 return DDI_BUF_EMP_400MV_0DB_HSW;
  2832.         }
  2833. }
  2834.  
  2835. /* Properly updates "DP" with the correct signal levels. */
  2836. static void
  2837. intel_dp_set_signal_levels(struct intel_dp *intel_dp, uint32_t *DP)
  2838. {
  2839.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  2840.         enum port port = intel_dig_port->port;
  2841.         struct drm_device *dev = intel_dig_port->base.base.dev;
  2842.         uint32_t signal_levels, mask;
  2843.         uint8_t train_set = intel_dp->train_set[0];
  2844.  
  2845.         if (IS_HASWELL(dev) || IS_BROADWELL(dev)) {
  2846.                 signal_levels = intel_hsw_signal_levels(train_set);
  2847.                 mask = DDI_BUF_EMP_MASK;
  2848.         } else if (IS_CHERRYVIEW(dev)) {
  2849.                 signal_levels = intel_chv_signal_levels(intel_dp);
  2850.                 mask = 0;
  2851.         } else if (IS_VALLEYVIEW(dev)) {
  2852.                 signal_levels = intel_vlv_signal_levels(intel_dp);
  2853.                 mask = 0;
  2854.         } else if (IS_GEN7(dev) && port == PORT_A) {
  2855.                 signal_levels = intel_gen7_edp_signal_levels(train_set);
  2856.                 mask = EDP_LINK_TRAIN_VOL_EMP_MASK_IVB;
  2857.         } else if (IS_GEN6(dev) && port == PORT_A) {
  2858.                 signal_levels = intel_gen6_edp_signal_levels(train_set);
  2859.                 mask = EDP_LINK_TRAIN_VOL_EMP_MASK_SNB;
  2860.         } else {
  2861.                 signal_levels = intel_gen4_signal_levels(train_set);
  2862.                 mask = DP_VOLTAGE_MASK | DP_PRE_EMPHASIS_MASK;
  2863.         }
  2864.  
  2865.         DRM_DEBUG_KMS("Using signal levels %08x\n", signal_levels);
  2866.  
  2867.         *DP = (*DP & ~mask) | signal_levels;
  2868. }
  2869.  
  2870. static bool
  2871. intel_dp_set_link_train(struct intel_dp *intel_dp,
  2872.                         uint32_t *DP,
  2873.                         uint8_t dp_train_pat)
  2874. {
  2875.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  2876.         struct drm_device *dev = intel_dig_port->base.base.dev;
  2877.         struct drm_i915_private *dev_priv = dev->dev_private;
  2878.         enum port port = intel_dig_port->port;
  2879.         uint8_t buf[sizeof(intel_dp->train_set) + 1];
  2880.         int ret, len;
  2881.  
  2882.         if (HAS_DDI(dev)) {
  2883.                 uint32_t temp = I915_READ(DP_TP_CTL(port));
  2884.  
  2885.                 if (dp_train_pat & DP_LINK_SCRAMBLING_DISABLE)
  2886.                         temp |= DP_TP_CTL_SCRAMBLE_DISABLE;
  2887.                 else
  2888.                         temp &= ~DP_TP_CTL_SCRAMBLE_DISABLE;
  2889.  
  2890.                 temp &= ~DP_TP_CTL_LINK_TRAIN_MASK;
  2891.                 switch (dp_train_pat & DP_TRAINING_PATTERN_MASK) {
  2892.                 case DP_TRAINING_PATTERN_DISABLE:
  2893.                         temp |= DP_TP_CTL_LINK_TRAIN_NORMAL;
  2894.  
  2895.                         break;
  2896.                 case DP_TRAINING_PATTERN_1:
  2897.                         temp |= DP_TP_CTL_LINK_TRAIN_PAT1;
  2898.                         break;
  2899.                 case DP_TRAINING_PATTERN_2:
  2900.                         temp |= DP_TP_CTL_LINK_TRAIN_PAT2;
  2901.                         break;
  2902.                 case DP_TRAINING_PATTERN_3:
  2903.                         temp |= DP_TP_CTL_LINK_TRAIN_PAT3;
  2904.                         break;
  2905.                 }
  2906.                 I915_WRITE(DP_TP_CTL(port), temp);
  2907.  
  2908.         } else if (HAS_PCH_CPT(dev) && (IS_GEN7(dev) || port != PORT_A)) {
  2909.                 *DP &= ~DP_LINK_TRAIN_MASK_CPT;
  2910.  
  2911.                 switch (dp_train_pat & DP_TRAINING_PATTERN_MASK) {
  2912.                 case DP_TRAINING_PATTERN_DISABLE:
  2913.                         *DP |= DP_LINK_TRAIN_OFF_CPT;
  2914.                         break;
  2915.                 case DP_TRAINING_PATTERN_1:
  2916.                         *DP |= DP_LINK_TRAIN_PAT_1_CPT;
  2917.                         break;
  2918.                 case DP_TRAINING_PATTERN_2:
  2919.                         *DP |= DP_LINK_TRAIN_PAT_2_CPT;
  2920.                         break;
  2921.                 case DP_TRAINING_PATTERN_3:
  2922.                         DRM_ERROR("DP training pattern 3 not supported\n");
  2923.                         *DP |= DP_LINK_TRAIN_PAT_2_CPT;
  2924.                         break;
  2925.                 }
  2926.  
  2927.         } else {
  2928.                 *DP &= ~DP_LINK_TRAIN_MASK;
  2929.  
  2930.                 switch (dp_train_pat & DP_TRAINING_PATTERN_MASK) {
  2931.                 case DP_TRAINING_PATTERN_DISABLE:
  2932.                         *DP |= DP_LINK_TRAIN_OFF;
  2933.                         break;
  2934.                 case DP_TRAINING_PATTERN_1:
  2935.                         *DP |= DP_LINK_TRAIN_PAT_1;
  2936.                         break;
  2937.                 case DP_TRAINING_PATTERN_2:
  2938.                         *DP |= DP_LINK_TRAIN_PAT_2;
  2939.                         break;
  2940.                 case DP_TRAINING_PATTERN_3:
  2941.                         DRM_ERROR("DP training pattern 3 not supported\n");
  2942.                         *DP |= DP_LINK_TRAIN_PAT_2;
  2943.                         break;
  2944.                 }
  2945.         }
  2946.  
  2947.         I915_WRITE(intel_dp->output_reg, *DP);
  2948.         POSTING_READ(intel_dp->output_reg);
  2949.  
  2950.         buf[0] = dp_train_pat;
  2951.         if ((dp_train_pat & DP_TRAINING_PATTERN_MASK) ==
  2952.             DP_TRAINING_PATTERN_DISABLE) {
  2953.                 /* don't write DP_TRAINING_LANEx_SET on disable */
  2954.                 len = 1;
  2955.         } else {
  2956.                 /* DP_TRAINING_LANEx_SET follow DP_TRAINING_PATTERN_SET */
  2957.                 memcpy(buf + 1, intel_dp->train_set, intel_dp->lane_count);
  2958.                 len = intel_dp->lane_count + 1;
  2959.         }
  2960.  
  2961.         ret = drm_dp_dpcd_write(&intel_dp->aux, DP_TRAINING_PATTERN_SET,
  2962.                                         buf, len);
  2963.  
  2964.         return ret == len;
  2965. }
  2966.  
  2967. static bool
  2968. intel_dp_reset_link_train(struct intel_dp *intel_dp, uint32_t *DP,
  2969.                         uint8_t dp_train_pat)
  2970. {
  2971.         memset(intel_dp->train_set, 0, sizeof(intel_dp->train_set));
  2972.         intel_dp_set_signal_levels(intel_dp, DP);
  2973.         return intel_dp_set_link_train(intel_dp, DP, dp_train_pat);
  2974. }
  2975.  
  2976. static bool
  2977. intel_dp_update_link_train(struct intel_dp *intel_dp, uint32_t *DP,
  2978.                            const uint8_t link_status[DP_LINK_STATUS_SIZE])
  2979. {
  2980.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  2981.         struct drm_device *dev = intel_dig_port->base.base.dev;
  2982.         struct drm_i915_private *dev_priv = dev->dev_private;
  2983.         int ret;
  2984.  
  2985.         intel_get_adjust_train(intel_dp, link_status);
  2986.         intel_dp_set_signal_levels(intel_dp, DP);
  2987.  
  2988.         I915_WRITE(intel_dp->output_reg, *DP);
  2989.         POSTING_READ(intel_dp->output_reg);
  2990.  
  2991.         ret = drm_dp_dpcd_write(&intel_dp->aux, DP_TRAINING_LANE0_SET,
  2992.                                 intel_dp->train_set, intel_dp->lane_count);
  2993.  
  2994.         return ret == intel_dp->lane_count;
  2995. }
  2996.  
  2997. static void intel_dp_set_idle_link_train(struct intel_dp *intel_dp)
  2998. {
  2999.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3000.         struct drm_device *dev = intel_dig_port->base.base.dev;
  3001.         struct drm_i915_private *dev_priv = dev->dev_private;
  3002.         enum port port = intel_dig_port->port;
  3003.         uint32_t val;
  3004.  
  3005.         if (!HAS_DDI(dev))
  3006.                 return;
  3007.  
  3008.         val = I915_READ(DP_TP_CTL(port));
  3009.         val &= ~DP_TP_CTL_LINK_TRAIN_MASK;
  3010.         val |= DP_TP_CTL_LINK_TRAIN_IDLE;
  3011.         I915_WRITE(DP_TP_CTL(port), val);
  3012.  
  3013.         /*
  3014.          * On PORT_A we can have only eDP in SST mode. There the only reason
  3015.          * we need to set idle transmission mode is to work around a HW issue
  3016.          * where we enable the pipe while not in idle link-training mode.
  3017.          * In this case there is requirement to wait for a minimum number of
  3018.          * idle patterns to be sent.
  3019.          */
  3020.         if (port == PORT_A)
  3021.                 return;
  3022.  
  3023.         if (wait_for((I915_READ(DP_TP_STATUS(port)) & DP_TP_STATUS_IDLE_DONE),
  3024.                      1))
  3025.                 DRM_ERROR("Timed out waiting for DP idle patterns\n");
  3026. }
  3027.  
  3028. /* Enable corresponding port and start training pattern 1 */
  3029. void
  3030. intel_dp_start_link_train(struct intel_dp *intel_dp)
  3031. {
  3032.         struct drm_encoder *encoder = &dp_to_dig_port(intel_dp)->base.base;
  3033.         struct drm_device *dev = encoder->dev;
  3034.         int i;
  3035.         uint8_t voltage;
  3036.         int voltage_tries, loop_tries;
  3037.         uint32_t DP = intel_dp->DP;
  3038.         uint8_t link_config[2];
  3039.  
  3040.         if (HAS_DDI(dev))
  3041.                 intel_ddi_prepare_link_retrain(encoder);
  3042.  
  3043.         /* Write the link configuration data */
  3044.         link_config[0] = intel_dp->link_bw;
  3045.         link_config[1] = intel_dp->lane_count;
  3046.         if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
  3047.                 link_config[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
  3048.         drm_dp_dpcd_write(&intel_dp->aux, DP_LINK_BW_SET, link_config, 2);
  3049.  
  3050.         link_config[0] = 0;
  3051.         link_config[1] = DP_SET_ANSI_8B10B;
  3052.         drm_dp_dpcd_write(&intel_dp->aux, DP_DOWNSPREAD_CTRL, link_config, 2);
  3053.  
  3054.         DP |= DP_PORT_EN;
  3055.  
  3056.         /* clock recovery */
  3057.         if (!intel_dp_reset_link_train(intel_dp, &DP,
  3058.                                        DP_TRAINING_PATTERN_1 |
  3059.                                        DP_LINK_SCRAMBLING_DISABLE)) {
  3060.                 DRM_ERROR("failed to enable link training\n");
  3061.                 return;
  3062.         }
  3063.  
  3064.         voltage = 0xff;
  3065.         voltage_tries = 0;
  3066.         loop_tries = 0;
  3067.         for (;;) {
  3068.                 uint8_t     link_status[DP_LINK_STATUS_SIZE];
  3069.  
  3070.                 drm_dp_link_train_clock_recovery_delay(intel_dp->dpcd);
  3071.                 if (!intel_dp_get_link_status(intel_dp, link_status)) {
  3072.                         DRM_ERROR("failed to get link status\n");
  3073.                         break;
  3074.                 }
  3075.  
  3076.                 if (drm_dp_clock_recovery_ok(link_status, intel_dp->lane_count)) {
  3077.                         DRM_DEBUG_KMS("clock recovery OK\n");
  3078.                         break;
  3079.                 }
  3080.  
  3081.                 /* Check to see if we've tried the max voltage */
  3082.                 for (i = 0; i < intel_dp->lane_count; i++)
  3083.                         if ((intel_dp->train_set[i] & DP_TRAIN_MAX_SWING_REACHED) == 0)
  3084.                                 break;
  3085.                 if (i == intel_dp->lane_count) {
  3086.                         ++loop_tries;
  3087.                         if (loop_tries == 5) {
  3088.                                 DRM_ERROR("too many full retries, give up\n");
  3089.                         break;
  3090.                         }
  3091.                         intel_dp_reset_link_train(intel_dp, &DP,
  3092.                                                   DP_TRAINING_PATTERN_1 |
  3093.                                                   DP_LINK_SCRAMBLING_DISABLE);
  3094.                         voltage_tries = 0;
  3095.                         continue;
  3096.                 }
  3097.  
  3098.                 /* Check to see if we've tried the same voltage 5 times */
  3099.                 if ((intel_dp->train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK) == voltage) {
  3100.                         ++voltage_tries;
  3101.                         if (voltage_tries == 5) {
  3102.                                 DRM_ERROR("too many voltage retries, give up\n");
  3103.                                 break;
  3104.                         }
  3105.                 } else
  3106.                         voltage_tries = 0;
  3107.                 voltage = intel_dp->train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK;
  3108.  
  3109.                 /* Update training set as requested by target */
  3110.                 if (!intel_dp_update_link_train(intel_dp, &DP, link_status)) {
  3111.                         DRM_ERROR("failed to update link training\n");
  3112.                         break;
  3113.                 }
  3114.         }
  3115.  
  3116.         intel_dp->DP = DP;
  3117. }
  3118.  
  3119. void
  3120. intel_dp_complete_link_train(struct intel_dp *intel_dp)
  3121. {
  3122.         bool channel_eq = false;
  3123.         int tries, cr_tries;
  3124.         uint32_t DP = intel_dp->DP;
  3125.         uint32_t training_pattern = DP_TRAINING_PATTERN_2;
  3126.  
  3127.         /* Training Pattern 3 for HBR2 ot 1.2 devices that support it*/
  3128.         if (intel_dp->link_bw == DP_LINK_BW_5_4 || intel_dp->use_tps3)
  3129.                 training_pattern = DP_TRAINING_PATTERN_3;
  3130.  
  3131.         /* channel equalization */
  3132.         if (!intel_dp_set_link_train(intel_dp, &DP,
  3133.                                      training_pattern |
  3134.                                      DP_LINK_SCRAMBLING_DISABLE)) {
  3135.                 DRM_ERROR("failed to start channel equalization\n");
  3136.                 return;
  3137.         }
  3138.  
  3139.         tries = 0;
  3140.         cr_tries = 0;
  3141.         channel_eq = false;
  3142.         for (;;) {
  3143.                 uint8_t     link_status[DP_LINK_STATUS_SIZE];
  3144.  
  3145.                 if (cr_tries > 5) {
  3146.                         DRM_ERROR("failed to train DP, aborting\n");
  3147.                         break;
  3148.                 }
  3149.  
  3150.                 drm_dp_link_train_channel_eq_delay(intel_dp->dpcd);
  3151.                 if (!intel_dp_get_link_status(intel_dp, link_status)) {
  3152.                         DRM_ERROR("failed to get link status\n");
  3153.                         break;
  3154.                 }
  3155.  
  3156.                 /* Make sure clock is still ok */
  3157.                 if (!drm_dp_clock_recovery_ok(link_status, intel_dp->lane_count)) {
  3158.                         intel_dp_start_link_train(intel_dp);
  3159.                         intel_dp_set_link_train(intel_dp, &DP,
  3160.                                                 training_pattern |
  3161.                                                 DP_LINK_SCRAMBLING_DISABLE);
  3162.                         cr_tries++;
  3163.                         continue;
  3164.                 }
  3165.  
  3166.                 if (drm_dp_channel_eq_ok(link_status, intel_dp->lane_count)) {
  3167.                         channel_eq = true;
  3168.                         break;
  3169.                 }
  3170.  
  3171.                 /* Try 5 times, then try clock recovery if that fails */
  3172.                 if (tries > 5) {
  3173.                         intel_dp_link_down(intel_dp);
  3174.                         intel_dp_start_link_train(intel_dp);
  3175.                         intel_dp_set_link_train(intel_dp, &DP,
  3176.                                                 training_pattern |
  3177.                                                 DP_LINK_SCRAMBLING_DISABLE);
  3178.                         tries = 0;
  3179.                         cr_tries++;
  3180.                         continue;
  3181.                 }
  3182.  
  3183.                 /* Update training set as requested by target */
  3184.                 if (!intel_dp_update_link_train(intel_dp, &DP, link_status)) {
  3185.                         DRM_ERROR("failed to update link training\n");
  3186.                         break;
  3187.                 }
  3188.                 ++tries;
  3189.         }
  3190.  
  3191.         intel_dp_set_idle_link_train(intel_dp);
  3192.  
  3193.         intel_dp->DP = DP;
  3194.  
  3195.         if (channel_eq)
  3196.                 DRM_DEBUG_KMS("Channel EQ done. DP Training successful\n");
  3197.  
  3198. }
  3199.  
  3200. void intel_dp_stop_link_train(struct intel_dp *intel_dp)
  3201. {
  3202.         intel_dp_set_link_train(intel_dp, &intel_dp->DP,
  3203.                                 DP_TRAINING_PATTERN_DISABLE);
  3204. }
  3205.  
  3206. static void
  3207. intel_dp_link_down(struct intel_dp *intel_dp)
  3208. {
  3209.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3210.         enum port port = intel_dig_port->port;
  3211.         struct drm_device *dev = intel_dig_port->base.base.dev;
  3212.         struct drm_i915_private *dev_priv = dev->dev_private;
  3213.         struct intel_crtc *intel_crtc =
  3214.                 to_intel_crtc(intel_dig_port->base.base.crtc);
  3215.         uint32_t DP = intel_dp->DP;
  3216.  
  3217.         if (WARN_ON(HAS_DDI(dev)))
  3218.                 return;
  3219.  
  3220.         if (WARN_ON((I915_READ(intel_dp->output_reg) & DP_PORT_EN) == 0))
  3221.                 return;
  3222.  
  3223.         DRM_DEBUG_KMS("\n");
  3224.  
  3225.         if (HAS_PCH_CPT(dev) && (IS_GEN7(dev) || port != PORT_A)) {
  3226.                 DP &= ~DP_LINK_TRAIN_MASK_CPT;
  3227.                 I915_WRITE(intel_dp->output_reg, DP | DP_LINK_TRAIN_PAT_IDLE_CPT);
  3228.         } else {
  3229.                 DP &= ~DP_LINK_TRAIN_MASK;
  3230.                 I915_WRITE(intel_dp->output_reg, DP | DP_LINK_TRAIN_PAT_IDLE);
  3231.         }
  3232.         POSTING_READ(intel_dp->output_reg);
  3233.  
  3234.         if (HAS_PCH_IBX(dev) &&
  3235.             I915_READ(intel_dp->output_reg) & DP_PIPEB_SELECT) {
  3236.                 struct drm_crtc *crtc = intel_dig_port->base.base.crtc;
  3237.  
  3238.                 /* Hardware workaround: leaving our transcoder select
  3239.                  * set to transcoder B while it's off will prevent the
  3240.                  * corresponding HDMI output on transcoder A.
  3241.                  *
  3242.                  * Combine this with another hardware workaround:
  3243.                  * transcoder select bit can only be cleared while the
  3244.                  * port is enabled.
  3245.                  */
  3246.                 DP &= ~DP_PIPEB_SELECT;
  3247.                 I915_WRITE(intel_dp->output_reg, DP);
  3248.  
  3249.                 /* Changes to enable or select take place the vblank
  3250.                  * after being written.
  3251.                  */
  3252.                 if (WARN_ON(crtc == NULL)) {
  3253.                         /* We should never try to disable a port without a crtc
  3254.                          * attached. For paranoia keep the code around for a
  3255.                          * bit. */
  3256.                         POSTING_READ(intel_dp->output_reg);
  3257.                         msleep(50);
  3258.                 } else
  3259.                         intel_wait_for_vblank(dev, intel_crtc->pipe);
  3260.         }
  3261.  
  3262.         DP &= ~DP_AUDIO_OUTPUT_ENABLE;
  3263.         I915_WRITE(intel_dp->output_reg, DP & ~DP_PORT_EN);
  3264.         POSTING_READ(intel_dp->output_reg);
  3265.         msleep(intel_dp->panel_power_down_delay);
  3266. }
  3267.  
  3268. static bool
  3269. intel_dp_get_dpcd(struct intel_dp *intel_dp)
  3270. {
  3271.         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
  3272.         struct drm_device *dev = dig_port->base.base.dev;
  3273.         struct drm_i915_private *dev_priv = dev->dev_private;
  3274.  
  3275.         char dpcd_hex_dump[sizeof(intel_dp->dpcd) * 3];
  3276.  
  3277.         if (intel_dp_dpcd_read_wake(&intel_dp->aux, 0x000, intel_dp->dpcd,
  3278.                                     sizeof(intel_dp->dpcd)) < 0)
  3279.                 return false; /* aux transfer failed */
  3280.  
  3281.         hex_dump_to_buffer(intel_dp->dpcd, sizeof(intel_dp->dpcd),
  3282.                            32, 1, dpcd_hex_dump, sizeof(dpcd_hex_dump), false);
  3283.         DRM_DEBUG_KMS("DPCD: %s\n", dpcd_hex_dump);
  3284.  
  3285.         if (intel_dp->dpcd[DP_DPCD_REV] == 0)
  3286.                 return false; /* DPCD not present */
  3287.  
  3288.         /* Check if the panel supports PSR */
  3289.         memset(intel_dp->psr_dpcd, 0, sizeof(intel_dp->psr_dpcd));
  3290.         if (is_edp(intel_dp)) {
  3291.                 intel_dp_dpcd_read_wake(&intel_dp->aux, DP_PSR_SUPPORT,
  3292.                                        intel_dp->psr_dpcd,
  3293.                                        sizeof(intel_dp->psr_dpcd));
  3294.                 if (intel_dp->psr_dpcd[0] & DP_PSR_IS_SUPPORTED) {
  3295.                         dev_priv->psr.sink_support = true;
  3296.                 DRM_DEBUG_KMS("Detected EDP PSR Panel.\n");
  3297.                 }
  3298.         }
  3299.  
  3300.         /* Training Pattern 3 support */
  3301.         if (intel_dp->dpcd[DP_DPCD_REV] >= 0x12 &&
  3302.             intel_dp->dpcd[DP_MAX_LANE_COUNT] & DP_TPS3_SUPPORTED) {
  3303.                 intel_dp->use_tps3 = true;
  3304.                 DRM_DEBUG_KMS("Displayport TPS3 supported");
  3305.         } else
  3306.                 intel_dp->use_tps3 = false;
  3307.  
  3308.         if (!(intel_dp->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
  3309.               DP_DWN_STRM_PORT_PRESENT))
  3310.                 return true; /* native DP sink */
  3311.  
  3312.         if (intel_dp->dpcd[DP_DPCD_REV] == 0x10)
  3313.                 return true; /* no per-port downstream info */
  3314.  
  3315.         if (intel_dp_dpcd_read_wake(&intel_dp->aux, DP_DOWNSTREAM_PORT_0,
  3316.                                            intel_dp->downstream_ports,
  3317.                                     DP_MAX_DOWNSTREAM_PORTS) < 0)
  3318.                 return false; /* downstream port status fetch failed */
  3319.  
  3320.                 return true;
  3321. }
  3322.  
  3323. static void
  3324. intel_dp_probe_oui(struct intel_dp *intel_dp)
  3325. {
  3326.         u8 buf[3];
  3327.  
  3328.         if (!(intel_dp->dpcd[DP_DOWN_STREAM_PORT_COUNT] & DP_OUI_SUPPORT))
  3329.                 return;
  3330.  
  3331.         intel_edp_panel_vdd_on(intel_dp);
  3332.  
  3333.         if (intel_dp_dpcd_read_wake(&intel_dp->aux, DP_SINK_OUI, buf, 3) == 3)
  3334.                 DRM_DEBUG_KMS("Sink OUI: %02hx%02hx%02hx\n",
  3335.                               buf[0], buf[1], buf[2]);
  3336.  
  3337.         if (intel_dp_dpcd_read_wake(&intel_dp->aux, DP_BRANCH_OUI, buf, 3) == 3)
  3338.                 DRM_DEBUG_KMS("Branch OUI: %02hx%02hx%02hx\n",
  3339.                               buf[0], buf[1], buf[2]);
  3340.  
  3341.         edp_panel_vdd_off(intel_dp, false);
  3342. }
  3343.  
  3344. static bool
  3345. intel_dp_probe_mst(struct intel_dp *intel_dp)
  3346. {
  3347.         u8 buf[1];
  3348.  
  3349.         if (!intel_dp->can_mst)
  3350.                 return false;
  3351.  
  3352.         if (intel_dp->dpcd[DP_DPCD_REV] < 0x12)
  3353.                 return false;
  3354.  
  3355.         _edp_panel_vdd_on(intel_dp);
  3356.         if (intel_dp_dpcd_read_wake(&intel_dp->aux, DP_MSTM_CAP, buf, 1)) {
  3357.                 if (buf[0] & DP_MST_CAP) {
  3358.                         DRM_DEBUG_KMS("Sink is MST capable\n");
  3359.                         intel_dp->is_mst = true;
  3360.                 } else {
  3361.                         DRM_DEBUG_KMS("Sink is not MST capable\n");
  3362.                         intel_dp->is_mst = false;
  3363.                 }
  3364.         }
  3365.         edp_panel_vdd_off(intel_dp, false);
  3366.  
  3367.         drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr, intel_dp->is_mst);
  3368.         return intel_dp->is_mst;
  3369. }
  3370.  
  3371. int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc)
  3372. {
  3373.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3374.         struct drm_device *dev = intel_dig_port->base.base.dev;
  3375.         struct intel_crtc *intel_crtc =
  3376.                 to_intel_crtc(intel_dig_port->base.base.crtc);
  3377.         u8 buf[1];
  3378.  
  3379.         if (drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_SINK_MISC, buf) < 0)
  3380.                 return -EAGAIN;
  3381.  
  3382.         if (!(buf[0] & DP_TEST_CRC_SUPPORTED))
  3383.                 return -ENOTTY;
  3384.  
  3385.         if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_SINK,
  3386.                                DP_TEST_SINK_START) < 0)
  3387.                 return -EAGAIN;
  3388.  
  3389.         /* Wait 2 vblanks to be sure we will have the correct CRC value */
  3390.         intel_wait_for_vblank(dev, intel_crtc->pipe);
  3391.         intel_wait_for_vblank(dev, intel_crtc->pipe);
  3392.  
  3393.         if (drm_dp_dpcd_read(&intel_dp->aux, DP_TEST_CRC_R_CR, crc, 6) < 0)
  3394.                 return -EAGAIN;
  3395.  
  3396.         drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_SINK, 0);
  3397.         return 0;
  3398. }
  3399.  
  3400. static bool
  3401. intel_dp_get_sink_irq(struct intel_dp *intel_dp, u8 *sink_irq_vector)
  3402. {
  3403.         return intel_dp_dpcd_read_wake(&intel_dp->aux,
  3404.                                              DP_DEVICE_SERVICE_IRQ_VECTOR,
  3405.                                        sink_irq_vector, 1) == 1;
  3406. }
  3407.  
  3408. static bool
  3409. intel_dp_get_sink_irq_esi(struct intel_dp *intel_dp, u8 *sink_irq_vector)
  3410. {
  3411.         int ret;
  3412.  
  3413.         ret = intel_dp_dpcd_read_wake(&intel_dp->aux,
  3414.                                              DP_SINK_COUNT_ESI,
  3415.                                              sink_irq_vector, 14);
  3416.         if (ret != 14)
  3417.                 return false;
  3418.  
  3419.         return true;
  3420. }
  3421.  
  3422. static void
  3423. intel_dp_handle_test_request(struct intel_dp *intel_dp)
  3424. {
  3425.         /* NAK by default */
  3426.         drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_RESPONSE, DP_TEST_NAK);
  3427. }
  3428.  
  3429. static int
  3430. intel_dp_check_mst_status(struct intel_dp *intel_dp)
  3431. {
  3432.         bool bret;
  3433.  
  3434.         if (intel_dp->is_mst) {
  3435.                 u8 esi[16] = { 0 };
  3436.                 int ret = 0;
  3437.                 int retry;
  3438.                 bool handled;
  3439.                 bret = intel_dp_get_sink_irq_esi(intel_dp, esi);
  3440. go_again:
  3441.                 if (bret == true) {
  3442.  
  3443.                         /* check link status - esi[10] = 0x200c */
  3444.                         if (intel_dp->active_mst_links && !drm_dp_channel_eq_ok(&esi[10], intel_dp->lane_count)) {
  3445.                                 DRM_DEBUG_KMS("channel EQ not ok, retraining\n");
  3446.                                 intel_dp_start_link_train(intel_dp);
  3447.                                 intel_dp_complete_link_train(intel_dp);
  3448.                                 intel_dp_stop_link_train(intel_dp);
  3449.                         }
  3450.  
  3451.                         DRM_DEBUG_KMS("got esi %02x %02x %02x\n", esi[0], esi[1], esi[2]);
  3452.                         ret = drm_dp_mst_hpd_irq(&intel_dp->mst_mgr, esi, &handled);
  3453.  
  3454.                         if (handled) {
  3455.                                 for (retry = 0; retry < 3; retry++) {
  3456.                                         int wret;
  3457.                                         wret = drm_dp_dpcd_write(&intel_dp->aux,
  3458.                                                                  DP_SINK_COUNT_ESI+1,
  3459.                                                                  &esi[1], 3);
  3460.                                         if (wret == 3) {
  3461.                                                 break;
  3462.                                         }
  3463.                                 }
  3464.  
  3465.                                 bret = intel_dp_get_sink_irq_esi(intel_dp, esi);
  3466.                                 if (bret == true) {
  3467.                                         DRM_DEBUG_KMS("got esi2 %02x %02x %02x\n", esi[0], esi[1], esi[2]);
  3468.                                         goto go_again;
  3469.                                 }
  3470.                         } else
  3471.                                 ret = 0;
  3472.  
  3473.                         return ret;
  3474.                 } else {
  3475.                         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3476.                         DRM_DEBUG_KMS("failed to get ESI - device may have failed\n");
  3477.                         intel_dp->is_mst = false;
  3478.                         drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr, intel_dp->is_mst);
  3479.                         /* send a hotplug event */
  3480.                         drm_kms_helper_hotplug_event(intel_dig_port->base.base.dev);
  3481.                 }
  3482.         }
  3483.         return -EINVAL;
  3484. }
  3485.  
  3486. /*
  3487.  * According to DP spec
  3488.  * 5.1.2:
  3489.  *  1. Read DPCD
  3490.  *  2. Configure link according to Receiver Capabilities
  3491.  *  3. Use Link Training from 2.5.3.3 and 3.5.1.3
  3492.  *  4. Check link status on receipt of hot-plug interrupt
  3493.  */
  3494. void
  3495. intel_dp_check_link_status(struct intel_dp *intel_dp)
  3496. {
  3497.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  3498.         struct intel_encoder *intel_encoder = &dp_to_dig_port(intel_dp)->base;
  3499.         u8 sink_irq_vector;
  3500.         u8 link_status[DP_LINK_STATUS_SIZE];
  3501.  
  3502.         WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
  3503.  
  3504.         if (!intel_encoder->connectors_active)
  3505.                 return;
  3506.  
  3507.         if (WARN_ON(!intel_encoder->base.crtc))
  3508.                 return;
  3509.  
  3510.         if (!to_intel_crtc(intel_encoder->base.crtc)->active)
  3511.                 return;
  3512.  
  3513.         /* Try to read receiver status if the link appears to be up */
  3514.         if (!intel_dp_get_link_status(intel_dp, link_status)) {
  3515.                 return;
  3516.         }
  3517.  
  3518.         /* Now read the DPCD to see if it's actually running */
  3519.         if (!intel_dp_get_dpcd(intel_dp)) {
  3520.                 return;
  3521.         }
  3522.  
  3523.         /* Try to read the source of the interrupt */
  3524.         if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11 &&
  3525.             intel_dp_get_sink_irq(intel_dp, &sink_irq_vector)) {
  3526.                 /* Clear interrupt source */
  3527.                 drm_dp_dpcd_writeb(&intel_dp->aux,
  3528.                                             DP_DEVICE_SERVICE_IRQ_VECTOR,
  3529.                                             sink_irq_vector);
  3530.  
  3531.                 if (sink_irq_vector & DP_AUTOMATED_TEST_REQUEST)
  3532.                         intel_dp_handle_test_request(intel_dp);
  3533.                 if (sink_irq_vector & (DP_CP_IRQ | DP_SINK_SPECIFIC_IRQ))
  3534.                         DRM_DEBUG_DRIVER("CP or sink specific irq unhandled\n");
  3535.         }
  3536.  
  3537.         if (!drm_dp_channel_eq_ok(link_status, intel_dp->lane_count)) {
  3538.                 DRM_DEBUG_KMS("%s: channel EQ not ok, retraining\n",
  3539.                               intel_encoder->base.name);
  3540.                 intel_dp_start_link_train(intel_dp);
  3541.                 intel_dp_complete_link_train(intel_dp);
  3542.                 intel_dp_stop_link_train(intel_dp);
  3543.         }
  3544. }
  3545.  
  3546. /* XXX this is probably wrong for multiple downstream ports */
  3547. static enum drm_connector_status
  3548. intel_dp_detect_dpcd(struct intel_dp *intel_dp)
  3549. {
  3550.         uint8_t *dpcd = intel_dp->dpcd;
  3551.         uint8_t type;
  3552.  
  3553.         if (!intel_dp_get_dpcd(intel_dp))
  3554.                 return connector_status_disconnected;
  3555.  
  3556.         /* if there's no downstream port, we're done */
  3557.         if (!(dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT))
  3558.                 return connector_status_connected;
  3559.  
  3560.         /* If we're HPD-aware, SINK_COUNT changes dynamically */
  3561.         if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11 &&
  3562.             intel_dp->downstream_ports[0] & DP_DS_PORT_HPD) {
  3563.                 uint8_t reg;
  3564.  
  3565.                 if (intel_dp_dpcd_read_wake(&intel_dp->aux, DP_SINK_COUNT,
  3566.                                             &reg, 1) < 0)
  3567.                         return connector_status_unknown;
  3568.  
  3569.                 return DP_GET_SINK_COUNT(reg) ? connector_status_connected
  3570.                                               : connector_status_disconnected;
  3571.         }
  3572.  
  3573.         /* If no HPD, poke DDC gently */
  3574.         if (drm_probe_ddc(&intel_dp->aux.ddc))
  3575.                 return connector_status_connected;
  3576.  
  3577.         /* Well we tried, say unknown for unreliable port types */
  3578.         if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11) {
  3579.         type = intel_dp->downstream_ports[0] & DP_DS_PORT_TYPE_MASK;
  3580.                 if (type == DP_DS_PORT_TYPE_VGA ||
  3581.                     type == DP_DS_PORT_TYPE_NON_EDID)
  3582.                 return connector_status_unknown;
  3583.         } else {
  3584.                 type = intel_dp->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
  3585.                         DP_DWN_STRM_PORT_TYPE_MASK;
  3586.                 if (type == DP_DWN_STRM_PORT_TYPE_ANALOG ||
  3587.                     type == DP_DWN_STRM_PORT_TYPE_OTHER)
  3588.                         return connector_status_unknown;
  3589.         }
  3590.  
  3591.         /* Anything else is out of spec, warn and ignore */
  3592.         DRM_DEBUG_KMS("Broken DP branch device, ignoring\n");
  3593.         return connector_status_disconnected;
  3594. }
  3595.  
  3596. static enum drm_connector_status
  3597. ironlake_dp_detect(struct intel_dp *intel_dp)
  3598. {
  3599.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  3600.         struct drm_i915_private *dev_priv = dev->dev_private;
  3601.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3602.         enum drm_connector_status status;
  3603.  
  3604.         /* Can't disconnect eDP, but you can close the lid... */
  3605.         if (is_edp(intel_dp)) {
  3606.                 status = intel_panel_detect(dev);
  3607.                 if (status == connector_status_unknown)
  3608.                         status = connector_status_connected;
  3609.                 return status;
  3610.         }
  3611.  
  3612.         if (!ibx_digital_port_connected(dev_priv, intel_dig_port))
  3613.                 return connector_status_disconnected;
  3614.  
  3615.         return intel_dp_detect_dpcd(intel_dp);
  3616. }
  3617.  
  3618. static int g4x_digital_port_connected(struct drm_device *dev,
  3619.                                        struct intel_digital_port *intel_dig_port)
  3620. {
  3621.         struct drm_i915_private *dev_priv = dev->dev_private;
  3622.         uint32_t bit;
  3623.  
  3624.         if (IS_VALLEYVIEW(dev)) {
  3625.                 switch (intel_dig_port->port) {
  3626.                 case PORT_B:
  3627.                         bit = PORTB_HOTPLUG_LIVE_STATUS_VLV;
  3628.                         break;
  3629.                 case PORT_C:
  3630.                         bit = PORTC_HOTPLUG_LIVE_STATUS_VLV;
  3631.                         break;
  3632.                 case PORT_D:
  3633.                         bit = PORTD_HOTPLUG_LIVE_STATUS_VLV;
  3634.                         break;
  3635.                 default:
  3636.                         return -EINVAL;
  3637.                 }
  3638.         } else {
  3639.         switch (intel_dig_port->port) {
  3640.         case PORT_B:
  3641.                         bit = PORTB_HOTPLUG_LIVE_STATUS_G4X;
  3642.                 break;
  3643.         case PORT_C:
  3644.                         bit = PORTC_HOTPLUG_LIVE_STATUS_G4X;
  3645.                 break;
  3646.         case PORT_D:
  3647.                         bit = PORTD_HOTPLUG_LIVE_STATUS_G4X;
  3648.                 break;
  3649.         default:
  3650.                         return -EINVAL;
  3651.         }
  3652.         }
  3653.  
  3654.         if ((I915_READ(PORT_HOTPLUG_STAT) & bit) == 0)
  3655.                 return 0;
  3656.         return 1;
  3657. }
  3658.  
  3659. static enum drm_connector_status
  3660. g4x_dp_detect(struct intel_dp *intel_dp)
  3661. {
  3662.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  3663.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3664.         int ret;
  3665.  
  3666.         /* Can't disconnect eDP, but you can close the lid... */
  3667.         if (is_edp(intel_dp)) {
  3668.                 enum drm_connector_status status;
  3669.  
  3670.                 status = intel_panel_detect(dev);
  3671.                 if (status == connector_status_unknown)
  3672.                         status = connector_status_connected;
  3673.                 return status;
  3674.         }
  3675.  
  3676.         ret = g4x_digital_port_connected(dev, intel_dig_port);
  3677.         if (ret == -EINVAL)
  3678.                 return connector_status_unknown;
  3679.         else if (ret == 0)
  3680.                 return connector_status_disconnected;
  3681.  
  3682.         return intel_dp_detect_dpcd(intel_dp);
  3683. }
  3684.  
  3685. static struct edid *
  3686. intel_dp_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter)
  3687. {
  3688.         struct intel_connector *intel_connector = to_intel_connector(connector);
  3689.  
  3690.         /* use cached edid if we have one */
  3691.         if (intel_connector->edid) {
  3692.                 /* invalid edid */
  3693.                 if (IS_ERR(intel_connector->edid))
  3694.                         return NULL;
  3695.  
  3696.                 return drm_edid_duplicate(intel_connector->edid);
  3697.         }
  3698.  
  3699.         return drm_get_edid(connector, adapter);
  3700. }
  3701.  
  3702. static int
  3703. intel_dp_get_edid_modes(struct drm_connector *connector, struct i2c_adapter *adapter)
  3704. {
  3705.         struct intel_connector *intel_connector = to_intel_connector(connector);
  3706.  
  3707.         /* use cached edid if we have one */
  3708.         if (intel_connector->edid) {
  3709.                 /* invalid edid */
  3710.                 if (IS_ERR(intel_connector->edid))
  3711.                         return 0;
  3712.  
  3713.                 return intel_connector_update_modes(connector,
  3714.                                                     intel_connector->edid);
  3715.         }
  3716.  
  3717.         return intel_ddc_get_modes(connector, adapter);
  3718. }
  3719.  
  3720. static enum drm_connector_status
  3721. intel_dp_detect(struct drm_connector *connector, bool force)
  3722. {
  3723.         struct intel_dp *intel_dp = intel_attached_dp(connector);
  3724.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3725.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  3726.         struct drm_device *dev = connector->dev;
  3727.         struct drm_i915_private *dev_priv = dev->dev_private;
  3728.         enum drm_connector_status status;
  3729.         enum intel_display_power_domain power_domain;
  3730.         struct edid *edid = NULL;
  3731.         bool ret;
  3732.  
  3733.         power_domain = intel_display_port_power_domain(intel_encoder);
  3734.         intel_display_power_get(dev_priv, power_domain);
  3735.  
  3736.         DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
  3737.                       connector->base.id, connector->name);
  3738.  
  3739.         if (intel_dp->is_mst) {
  3740.                 /* MST devices are disconnected from a monitor POV */
  3741.                 if (intel_encoder->type != INTEL_OUTPUT_EDP)
  3742.                         intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT;
  3743.                 status = connector_status_disconnected;
  3744.                 goto out;
  3745.         }
  3746.  
  3747.         intel_dp->has_audio = false;
  3748.  
  3749.         if (HAS_PCH_SPLIT(dev))
  3750.                 status = ironlake_dp_detect(intel_dp);
  3751.         else
  3752.                 status = g4x_dp_detect(intel_dp);
  3753.  
  3754.         if (status != connector_status_connected)
  3755.                 goto out;
  3756.  
  3757.         intel_dp_probe_oui(intel_dp);
  3758.  
  3759.         ret = intel_dp_probe_mst(intel_dp);
  3760.         if (ret) {
  3761.                 /* if we are in MST mode then this connector
  3762.                    won't appear connected or have anything with EDID on it */
  3763.                 if (intel_encoder->type != INTEL_OUTPUT_EDP)
  3764.                         intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT;
  3765.                 status = connector_status_disconnected;
  3766.                 goto out;
  3767.         }
  3768.  
  3769.         if (intel_dp->force_audio != HDMI_AUDIO_AUTO) {
  3770.                 intel_dp->has_audio = (intel_dp->force_audio == HDMI_AUDIO_ON);
  3771.         } else {
  3772.                 edid = intel_dp_get_edid(connector, &intel_dp->aux.ddc);
  3773.                 if (edid) {
  3774.                         intel_dp->has_audio = drm_detect_monitor_audio(edid);
  3775.                         kfree(edid);
  3776.                 }
  3777.         }
  3778.  
  3779.         if (intel_encoder->type != INTEL_OUTPUT_EDP)
  3780.                 intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT;
  3781.         status = connector_status_connected;
  3782.  
  3783. out:
  3784.         intel_display_power_put(dev_priv, power_domain);
  3785.         return status;
  3786. }
  3787.  
  3788. static int intel_dp_get_modes(struct drm_connector *connector)
  3789. {
  3790.         struct intel_dp *intel_dp = intel_attached_dp(connector);
  3791.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3792.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  3793.         struct intel_connector *intel_connector = to_intel_connector(connector);
  3794.         struct drm_device *dev = connector->dev;
  3795.         struct drm_i915_private *dev_priv = dev->dev_private;
  3796.         enum intel_display_power_domain power_domain;
  3797.         int ret;
  3798.  
  3799.         /* We should parse the EDID data and find out if it has an audio sink
  3800.          */
  3801.  
  3802.         power_domain = intel_display_port_power_domain(intel_encoder);
  3803.         intel_display_power_get(dev_priv, power_domain);
  3804.  
  3805.         ret = intel_dp_get_edid_modes(connector, &intel_dp->aux.ddc);
  3806.         intel_display_power_put(dev_priv, power_domain);
  3807.         if (ret)
  3808.                 return ret;
  3809.  
  3810.         /* if eDP has no EDID, fall back to fixed mode */
  3811.         if (is_edp(intel_dp) && intel_connector->panel.fixed_mode) {
  3812.                         struct drm_display_mode *mode;
  3813.                 mode = drm_mode_duplicate(dev,
  3814.                                           intel_connector->panel.fixed_mode);
  3815.                 if (mode) {
  3816.                         drm_mode_probed_add(connector, mode);
  3817.                         return 1;
  3818.                 }
  3819.         }
  3820.         return 0;
  3821. }
  3822.  
  3823. static bool
  3824. intel_dp_detect_audio(struct drm_connector *connector)
  3825. {
  3826.         struct intel_dp *intel_dp = intel_attached_dp(connector);
  3827.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  3828.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  3829.         struct drm_device *dev = connector->dev;
  3830.         struct drm_i915_private *dev_priv = dev->dev_private;
  3831.         enum intel_display_power_domain power_domain;
  3832.         struct edid *edid;
  3833.         bool has_audio = false;
  3834.  
  3835.         power_domain = intel_display_port_power_domain(intel_encoder);
  3836.         intel_display_power_get(dev_priv, power_domain);
  3837.  
  3838.         edid = intel_dp_get_edid(connector, &intel_dp->aux.ddc);
  3839.         if (edid) {
  3840.                 has_audio = drm_detect_monitor_audio(edid);
  3841.                 kfree(edid);
  3842.         }
  3843.  
  3844.         intel_display_power_put(dev_priv, power_domain);
  3845.  
  3846.         return has_audio;
  3847. }
  3848.  
  3849. static int
  3850. intel_dp_set_property(struct drm_connector *connector,
  3851.                       struct drm_property *property,
  3852.                       uint64_t val)
  3853. {
  3854.         struct drm_i915_private *dev_priv = connector->dev->dev_private;
  3855.         struct intel_connector *intel_connector = to_intel_connector(connector);
  3856.         struct intel_encoder *intel_encoder = intel_attached_encoder(connector);
  3857.         struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
  3858.         int ret;
  3859.  
  3860.         ret = drm_object_property_set_value(&connector->base, property, val);
  3861.         if (ret)
  3862.                 return ret;
  3863.  
  3864.         if (property == dev_priv->force_audio_property) {
  3865.                 int i = val;
  3866.                 bool has_audio;
  3867.  
  3868.                 if (i == intel_dp->force_audio)
  3869.                         return 0;
  3870.  
  3871.                 intel_dp->force_audio = i;
  3872.  
  3873.                 if (i == HDMI_AUDIO_AUTO)
  3874.                         has_audio = intel_dp_detect_audio(connector);
  3875.                 else
  3876.                         has_audio = (i == HDMI_AUDIO_ON);
  3877.  
  3878.                 if (has_audio == intel_dp->has_audio)
  3879.                         return 0;
  3880.  
  3881.                 intel_dp->has_audio = has_audio;
  3882.                 goto done;
  3883.         }
  3884.  
  3885.         if (property == dev_priv->broadcast_rgb_property) {
  3886.                 bool old_auto = intel_dp->color_range_auto;
  3887.                 uint32_t old_range = intel_dp->color_range;
  3888.  
  3889.                 switch (val) {
  3890.                 case INTEL_BROADCAST_RGB_AUTO:
  3891.                         intel_dp->color_range_auto = true;
  3892.                         break;
  3893.                 case INTEL_BROADCAST_RGB_FULL:
  3894.                         intel_dp->color_range_auto = false;
  3895.                         intel_dp->color_range = 0;
  3896.                         break;
  3897.                 case INTEL_BROADCAST_RGB_LIMITED:
  3898.                         intel_dp->color_range_auto = false;
  3899.                         intel_dp->color_range = DP_COLOR_RANGE_16_235;
  3900.                         break;
  3901.                 default:
  3902.                         return -EINVAL;
  3903.                 }
  3904.  
  3905.                 if (old_auto == intel_dp->color_range_auto &&
  3906.                     old_range == intel_dp->color_range)
  3907.                         return 0;
  3908.  
  3909.         goto done;
  3910.         }
  3911.  
  3912.         if (is_edp(intel_dp) &&
  3913.             property == connector->dev->mode_config.scaling_mode_property) {
  3914.                 if (val == DRM_MODE_SCALE_NONE) {
  3915.                         DRM_DEBUG_KMS("no scaling not supported\n");
  3916.                         return -EINVAL;
  3917.                 }
  3918.  
  3919.                 if (intel_connector->panel.fitting_mode == val) {
  3920.                         /* the eDP scaling property is not changed */
  3921.                         return 0;
  3922.                 }
  3923.                 intel_connector->panel.fitting_mode = val;
  3924.  
  3925.                 goto done;
  3926.         }
  3927.  
  3928.         return -EINVAL;
  3929.  
  3930. done:
  3931.         if (intel_encoder->base.crtc)
  3932.                 intel_crtc_restore_mode(intel_encoder->base.crtc);
  3933.  
  3934.         return 0;
  3935. }
  3936.  
  3937. static void
  3938. intel_dp_connector_destroy(struct drm_connector *connector)
  3939. {
  3940.         struct intel_connector *intel_connector = to_intel_connector(connector);
  3941.  
  3942.         if (!IS_ERR_OR_NULL(intel_connector->edid))
  3943.                 kfree(intel_connector->edid);
  3944.  
  3945.         /* Can't call is_edp() since the encoder may have been destroyed
  3946.          * already. */
  3947.         if (connector->connector_type == DRM_MODE_CONNECTOR_eDP)
  3948.                 intel_panel_fini(&intel_connector->panel);
  3949.  
  3950.         drm_connector_cleanup(connector);
  3951.         kfree(connector);
  3952. }
  3953.  
  3954. void intel_dp_encoder_destroy(struct drm_encoder *encoder)
  3955. {
  3956.         struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder);
  3957.         struct intel_dp *intel_dp = &intel_dig_port->dp;
  3958.         struct drm_device *dev = intel_dp_to_dev(intel_dp);
  3959.  
  3960.         drm_dp_aux_unregister(&intel_dp->aux);
  3961.         intel_dp_mst_encoder_cleanup(intel_dig_port);
  3962.         drm_encoder_cleanup(encoder);
  3963.         if (is_edp(intel_dp)) {
  3964.                 cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
  3965.                 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
  3966.                 edp_panel_vdd_off_sync(intel_dp);
  3967.                 drm_modeset_unlock(&dev->mode_config.connection_mutex);
  3968.         }
  3969.         kfree(intel_dig_port);
  3970. }
  3971.  
  3972. static void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
  3973. {
  3974.         struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
  3975.  
  3976.         if (!is_edp(intel_dp))
  3977.                 return;
  3978.  
  3979.         edp_panel_vdd_off_sync(intel_dp);
  3980. }
  3981.  
  3982. static void intel_dp_encoder_reset(struct drm_encoder *encoder)
  3983. {
  3984.         intel_edp_panel_vdd_sanitize(to_intel_encoder(encoder));
  3985. }
  3986.  
  3987. static const struct drm_connector_funcs intel_dp_connector_funcs = {
  3988.         .dpms = intel_connector_dpms,
  3989.         .detect = intel_dp_detect,
  3990.         .fill_modes = drm_helper_probe_single_connector_modes,
  3991.         .set_property = intel_dp_set_property,
  3992.         .destroy = intel_dp_connector_destroy,
  3993. };
  3994.  
  3995. static const struct drm_connector_helper_funcs intel_dp_connector_helper_funcs = {
  3996.         .get_modes = intel_dp_get_modes,
  3997.         .mode_valid = intel_dp_mode_valid,
  3998.         .best_encoder = intel_best_encoder,
  3999. };
  4000.  
  4001. static const struct drm_encoder_funcs intel_dp_enc_funcs = {
  4002.         .reset = intel_dp_encoder_reset,
  4003.         .destroy = intel_dp_encoder_destroy,
  4004. };
  4005.  
  4006. void
  4007. intel_dp_hot_plug(struct intel_encoder *intel_encoder)
  4008. {
  4009.         return;
  4010. }
  4011.  
  4012. bool
  4013. intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port, bool long_hpd)
  4014. {
  4015.         struct intel_dp *intel_dp = &intel_dig_port->dp;
  4016.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  4017.         struct drm_device *dev = intel_dig_port->base.base.dev;
  4018.         struct drm_i915_private *dev_priv = dev->dev_private;
  4019.         enum intel_display_power_domain power_domain;
  4020.         bool ret = true;
  4021.  
  4022.         if (intel_dig_port->base.type != INTEL_OUTPUT_EDP)
  4023.                 intel_dig_port->base.type = INTEL_OUTPUT_DISPLAYPORT;
  4024.  
  4025.         DRM_DEBUG_KMS("got hpd irq on port %d - %s\n", intel_dig_port->port,
  4026.                       long_hpd ? "long" : "short");
  4027.  
  4028.         power_domain = intel_display_port_power_domain(intel_encoder);
  4029.         intel_display_power_get(dev_priv, power_domain);
  4030.  
  4031.         if (long_hpd) {
  4032.  
  4033.                 if (HAS_PCH_SPLIT(dev)) {
  4034.                 if (!ibx_digital_port_connected(dev_priv, intel_dig_port))
  4035.                         goto mst_fail;
  4036.                 } else {
  4037.                         if (g4x_digital_port_connected(dev, intel_dig_port) != 1)
  4038.                                 goto mst_fail;
  4039.                 }
  4040.  
  4041.                 if (!intel_dp_get_dpcd(intel_dp)) {
  4042.                         goto mst_fail;
  4043.                 }
  4044.  
  4045.                 intel_dp_probe_oui(intel_dp);
  4046.  
  4047.                 if (!intel_dp_probe_mst(intel_dp))
  4048.                         goto mst_fail;
  4049.  
  4050.         } else {
  4051.                 if (intel_dp->is_mst) {
  4052.                         if (intel_dp_check_mst_status(intel_dp) == -EINVAL)
  4053.                                 goto mst_fail;
  4054.                 }
  4055.  
  4056.                 if (!intel_dp->is_mst) {
  4057.                         /*
  4058.                          * we'll check the link status via the normal hot plug path later -
  4059.                          * but for short hpds we should check it now
  4060.                          */
  4061.                         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
  4062.                         intel_dp_check_link_status(intel_dp);
  4063.                         drm_modeset_unlock(&dev->mode_config.connection_mutex);
  4064.                 }
  4065.         }
  4066.         ret = false;
  4067.         goto put_power;
  4068. mst_fail:
  4069.         /* if we were in MST mode, and device is not there get out of MST mode */
  4070.         if (intel_dp->is_mst) {
  4071.                 DRM_DEBUG_KMS("MST device may have disappeared %d vs %d\n", intel_dp->is_mst, intel_dp->mst_mgr.mst_state);
  4072.                 intel_dp->is_mst = false;
  4073.                 drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr, intel_dp->is_mst);
  4074.         }
  4075. put_power:
  4076.         intel_display_power_put(dev_priv, power_domain);
  4077.  
  4078.         return ret;
  4079. }
  4080.  
  4081. /* Return which DP Port should be selected for Transcoder DP control */
  4082. int
  4083. intel_trans_dp_port_sel(struct drm_crtc *crtc)
  4084. {
  4085.         struct drm_device *dev = crtc->dev;
  4086.         struct intel_encoder *intel_encoder;
  4087.         struct intel_dp *intel_dp;
  4088.  
  4089.         for_each_encoder_on_crtc(dev, crtc, intel_encoder) {
  4090.                 intel_dp = enc_to_intel_dp(&intel_encoder->base);
  4091.  
  4092.                 if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT ||
  4093.                     intel_encoder->type == INTEL_OUTPUT_EDP)
  4094.                         return intel_dp->output_reg;
  4095.         }
  4096.  
  4097.         return -1;
  4098. }
  4099.  
  4100. /* check the VBT to see whether the eDP is on DP-D port */
  4101. bool intel_dp_is_edp(struct drm_device *dev, enum port port)
  4102. {
  4103.         struct drm_i915_private *dev_priv = dev->dev_private;
  4104.         union child_device_config *p_child;
  4105.         int i;
  4106.         static const short port_mapping[] = {
  4107.                 [PORT_B] = PORT_IDPB,
  4108.                 [PORT_C] = PORT_IDPC,
  4109.                 [PORT_D] = PORT_IDPD,
  4110.         };
  4111.  
  4112.         if (port == PORT_A)
  4113.                 return true;
  4114.  
  4115.         if (!dev_priv->vbt.child_dev_num)
  4116.                 return false;
  4117.  
  4118.         for (i = 0; i < dev_priv->vbt.child_dev_num; i++) {
  4119.                 p_child = dev_priv->vbt.child_dev + i;
  4120.  
  4121.                 if (p_child->common.dvo_port == port_mapping[port] &&
  4122.                     (p_child->common.device_type & DEVICE_TYPE_eDP_BITS) ==
  4123.                     (DEVICE_TYPE_eDP & DEVICE_TYPE_eDP_BITS))
  4124.                         return true;
  4125.         }
  4126.         return false;
  4127. }
  4128.  
  4129. void
  4130. intel_dp_add_properties(struct intel_dp *intel_dp, struct drm_connector *connector)
  4131. {
  4132.         struct intel_connector *intel_connector = to_intel_connector(connector);
  4133.  
  4134.         intel_attach_force_audio_property(connector);
  4135.         intel_attach_broadcast_rgb_property(connector);
  4136.         intel_dp->color_range_auto = true;
  4137.  
  4138.         if (is_edp(intel_dp)) {
  4139.                 drm_mode_create_scaling_mode_property(connector->dev);
  4140.                 drm_object_attach_property(
  4141.                         &connector->base,
  4142.                         connector->dev->mode_config.scaling_mode_property,
  4143.                         DRM_MODE_SCALE_ASPECT);
  4144.                 intel_connector->panel.fitting_mode = DRM_MODE_SCALE_ASPECT;
  4145.         }
  4146. }
  4147.  
  4148. static void intel_dp_init_panel_power_timestamps(struct intel_dp *intel_dp)
  4149. {
  4150.         intel_dp->last_power_cycle = jiffies;
  4151.         intel_dp->last_power_on = jiffies;
  4152.         intel_dp->last_backlight_off = jiffies;
  4153. }
  4154.  
  4155. static void
  4156. intel_dp_init_panel_power_sequencer(struct drm_device *dev,
  4157.                                     struct intel_dp *intel_dp,
  4158.                                     struct edp_power_seq *out)
  4159. {
  4160.         struct drm_i915_private *dev_priv = dev->dev_private;
  4161.         struct edp_power_seq cur, vbt, spec, final;
  4162.         u32 pp_on, pp_off, pp_div, pp;
  4163.         int pp_ctrl_reg, pp_on_reg, pp_off_reg, pp_div_reg;
  4164.  
  4165.         if (HAS_PCH_SPLIT(dev)) {
  4166.                 pp_ctrl_reg = PCH_PP_CONTROL;
  4167.                 pp_on_reg = PCH_PP_ON_DELAYS;
  4168.                 pp_off_reg = PCH_PP_OFF_DELAYS;
  4169.                 pp_div_reg = PCH_PP_DIVISOR;
  4170.         } else {
  4171.                 enum pipe pipe = vlv_power_sequencer_pipe(intel_dp);
  4172.  
  4173.                 pp_ctrl_reg = VLV_PIPE_PP_CONTROL(pipe);
  4174.                 pp_on_reg = VLV_PIPE_PP_ON_DELAYS(pipe);
  4175.                 pp_off_reg = VLV_PIPE_PP_OFF_DELAYS(pipe);
  4176.                 pp_div_reg = VLV_PIPE_PP_DIVISOR(pipe);
  4177.         }
  4178.  
  4179.         /* Workaround: Need to write PP_CONTROL with the unlock key as
  4180.          * the very first thing. */
  4181.         pp = ironlake_get_pp_control(intel_dp);
  4182.         I915_WRITE(pp_ctrl_reg, pp);
  4183.  
  4184.         pp_on = I915_READ(pp_on_reg);
  4185.         pp_off = I915_READ(pp_off_reg);
  4186.         pp_div = I915_READ(pp_div_reg);
  4187.  
  4188.         /* Pull timing values out of registers */
  4189.         cur.t1_t3 = (pp_on & PANEL_POWER_UP_DELAY_MASK) >>
  4190.                 PANEL_POWER_UP_DELAY_SHIFT;
  4191.  
  4192.         cur.t8 = (pp_on & PANEL_LIGHT_ON_DELAY_MASK) >>
  4193.                 PANEL_LIGHT_ON_DELAY_SHIFT;
  4194.  
  4195.         cur.t9 = (pp_off & PANEL_LIGHT_OFF_DELAY_MASK) >>
  4196.                 PANEL_LIGHT_OFF_DELAY_SHIFT;
  4197.  
  4198.         cur.t10 = (pp_off & PANEL_POWER_DOWN_DELAY_MASK) >>
  4199.                 PANEL_POWER_DOWN_DELAY_SHIFT;
  4200.  
  4201.         cur.t11_t12 = ((pp_div & PANEL_POWER_CYCLE_DELAY_MASK) >>
  4202.                        PANEL_POWER_CYCLE_DELAY_SHIFT) * 1000;
  4203.  
  4204.         DRM_DEBUG_KMS("cur t1_t3 %d t8 %d t9 %d t10 %d t11_t12 %d\n",
  4205.                       cur.t1_t3, cur.t8, cur.t9, cur.t10, cur.t11_t12);
  4206.  
  4207.         vbt = dev_priv->vbt.edp_pps;
  4208.  
  4209.         /* Upper limits from eDP 1.3 spec. Note that we use the clunky units of
  4210.          * our hw here, which are all in 100usec. */
  4211.         spec.t1_t3 = 210 * 10;
  4212.         spec.t8 = 50 * 10; /* no limit for t8, use t7 instead */
  4213.         spec.t9 = 50 * 10; /* no limit for t9, make it symmetric with t8 */
  4214.         spec.t10 = 500 * 10;
  4215.         /* This one is special and actually in units of 100ms, but zero
  4216.          * based in the hw (so we need to add 100 ms). But the sw vbt
  4217.          * table multiplies it with 1000 to make it in units of 100usec,
  4218.          * too. */
  4219.         spec.t11_t12 = (510 + 100) * 10;
  4220.  
  4221.         DRM_DEBUG_KMS("vbt t1_t3 %d t8 %d t9 %d t10 %d t11_t12 %d\n",
  4222.                       vbt.t1_t3, vbt.t8, vbt.t9, vbt.t10, vbt.t11_t12);
  4223.  
  4224.         /* Use the max of the register settings and vbt. If both are
  4225.          * unset, fall back to the spec limits. */
  4226. #define assign_final(field)     final.field = (max(cur.field, vbt.field) == 0 ? \
  4227.                                        spec.field : \
  4228.                                        max(cur.field, vbt.field))
  4229.         assign_final(t1_t3);
  4230.         assign_final(t8);
  4231.         assign_final(t9);
  4232.         assign_final(t10);
  4233.         assign_final(t11_t12);
  4234. #undef assign_final
  4235.  
  4236. #define get_delay(field)        (DIV_ROUND_UP(final.field, 10))
  4237.         intel_dp->panel_power_up_delay = get_delay(t1_t3);
  4238.         intel_dp->backlight_on_delay = get_delay(t8);
  4239.         intel_dp->backlight_off_delay = get_delay(t9);
  4240.         intel_dp->panel_power_down_delay = get_delay(t10);
  4241.         intel_dp->panel_power_cycle_delay = get_delay(t11_t12);
  4242. #undef get_delay
  4243.  
  4244.         DRM_DEBUG_KMS("panel power up delay %d, power down delay %d, power cycle delay %d\n",
  4245.                       intel_dp->panel_power_up_delay, intel_dp->panel_power_down_delay,
  4246.                       intel_dp->panel_power_cycle_delay);
  4247.  
  4248.         DRM_DEBUG_KMS("backlight on delay %d, off delay %d\n",
  4249.                       intel_dp->backlight_on_delay, intel_dp->backlight_off_delay);
  4250.  
  4251.         if (out)
  4252.                 *out = final;
  4253. }
  4254.  
  4255. static void
  4256. intel_dp_init_panel_power_sequencer_registers(struct drm_device *dev,
  4257.                                               struct intel_dp *intel_dp,
  4258.                                               struct edp_power_seq *seq)
  4259. {
  4260.         struct drm_i915_private *dev_priv = dev->dev_private;
  4261.         u32 pp_on, pp_off, pp_div, port_sel = 0;
  4262.         int div = HAS_PCH_SPLIT(dev) ? intel_pch_rawclk(dev) : intel_hrawclk(dev);
  4263.         int pp_on_reg, pp_off_reg, pp_div_reg;
  4264.  
  4265.         if (HAS_PCH_SPLIT(dev)) {
  4266.                 pp_on_reg = PCH_PP_ON_DELAYS;
  4267.                 pp_off_reg = PCH_PP_OFF_DELAYS;
  4268.                 pp_div_reg = PCH_PP_DIVISOR;
  4269.         } else {
  4270.                 enum pipe pipe = vlv_power_sequencer_pipe(intel_dp);
  4271.  
  4272.                 pp_on_reg = VLV_PIPE_PP_ON_DELAYS(pipe);
  4273.                 pp_off_reg = VLV_PIPE_PP_OFF_DELAYS(pipe);
  4274.                 pp_div_reg = VLV_PIPE_PP_DIVISOR(pipe);
  4275.         }
  4276.  
  4277.         /*
  4278.          * And finally store the new values in the power sequencer. The
  4279.          * backlight delays are set to 1 because we do manual waits on them. For
  4280.          * T8, even BSpec recommends doing it. For T9, if we don't do this,
  4281.          * we'll end up waiting for the backlight off delay twice: once when we
  4282.          * do the manual sleep, and once when we disable the panel and wait for
  4283.          * the PP_STATUS bit to become zero.
  4284.          */
  4285.         pp_on = (seq->t1_t3 << PANEL_POWER_UP_DELAY_SHIFT) |
  4286.                 (1 << PANEL_LIGHT_ON_DELAY_SHIFT);
  4287.         pp_off = (1 << PANEL_LIGHT_OFF_DELAY_SHIFT) |
  4288.                  (seq->t10 << PANEL_POWER_DOWN_DELAY_SHIFT);
  4289.         /* Compute the divisor for the pp clock, simply match the Bspec
  4290.          * formula. */
  4291.         pp_div = ((100 * div)/2 - 1) << PP_REFERENCE_DIVIDER_SHIFT;
  4292.         pp_div |= (DIV_ROUND_UP(seq->t11_t12, 1000)
  4293.                         << PANEL_POWER_CYCLE_DELAY_SHIFT);
  4294.  
  4295.         /* Haswell doesn't have any port selection bits for the panel
  4296.          * power sequencer any more. */
  4297.         if (IS_VALLEYVIEW(dev)) {
  4298.                 if (dp_to_dig_port(intel_dp)->port == PORT_B)
  4299.                         port_sel = PANEL_PORT_SELECT_DPB_VLV;
  4300.                 else
  4301.                         port_sel = PANEL_PORT_SELECT_DPC_VLV;
  4302.         } else if (HAS_PCH_IBX(dev) || HAS_PCH_CPT(dev)) {
  4303.                 if (dp_to_dig_port(intel_dp)->port == PORT_A)
  4304.                         port_sel = PANEL_PORT_SELECT_DPA;
  4305.                 else
  4306.                         port_sel = PANEL_PORT_SELECT_DPD;
  4307.         }
  4308.  
  4309.         pp_on |= port_sel;
  4310.  
  4311.         I915_WRITE(pp_on_reg, pp_on);
  4312.         I915_WRITE(pp_off_reg, pp_off);
  4313.         I915_WRITE(pp_div_reg, pp_div);
  4314.  
  4315.         DRM_DEBUG_KMS("panel power sequencer register settings: PP_ON %#x, PP_OFF %#x, PP_DIV %#x\n",
  4316.                       I915_READ(pp_on_reg),
  4317.                       I915_READ(pp_off_reg),
  4318.                       I915_READ(pp_div_reg));
  4319. }
  4320.  
  4321. void intel_dp_set_drrs_state(struct drm_device *dev, int refresh_rate)
  4322. {
  4323.         struct drm_i915_private *dev_priv = dev->dev_private;
  4324.         struct intel_encoder *encoder;
  4325.         struct intel_dp *intel_dp = NULL;
  4326.         struct intel_crtc_config *config = NULL;
  4327.         struct intel_crtc *intel_crtc = NULL;
  4328.         struct intel_connector *intel_connector = dev_priv->drrs.connector;
  4329.         u32 reg, val;
  4330.         enum edp_drrs_refresh_rate_type index = DRRS_HIGH_RR;
  4331.  
  4332.         if (refresh_rate <= 0) {
  4333.                 DRM_DEBUG_KMS("Refresh rate should be positive non-zero.\n");
  4334.                 return;
  4335.         }
  4336.  
  4337.         if (intel_connector == NULL) {
  4338.                 DRM_DEBUG_KMS("DRRS supported for eDP only.\n");
  4339.                 return;
  4340.         }
  4341.  
  4342.         /*
  4343.          * FIXME: This needs proper synchronization with psr state. But really
  4344.          * hard to tell without seeing the user of this function of this code.
  4345.          * Check locking and ordering once that lands.
  4346.          */
  4347.         if (INTEL_INFO(dev)->gen < 8 && intel_edp_is_psr_enabled(dev)) {
  4348.                 DRM_DEBUG_KMS("DRRS is disabled as PSR is enabled\n");
  4349.                 return;
  4350.         }
  4351.  
  4352.         encoder = intel_attached_encoder(&intel_connector->base);
  4353.         intel_dp = enc_to_intel_dp(&encoder->base);
  4354.         intel_crtc = encoder->new_crtc;
  4355.  
  4356.         if (!intel_crtc) {
  4357.                 DRM_DEBUG_KMS("DRRS: intel_crtc not initialized\n");
  4358.                 return;
  4359.         }
  4360.  
  4361.         config = &intel_crtc->config;
  4362.  
  4363.         if (intel_dp->drrs_state.type < SEAMLESS_DRRS_SUPPORT) {
  4364.                 DRM_DEBUG_KMS("Only Seamless DRRS supported.\n");
  4365.                 return;
  4366.         }
  4367.  
  4368.         if (intel_connector->panel.downclock_mode->vrefresh == refresh_rate)
  4369.                 index = DRRS_LOW_RR;
  4370.  
  4371.         if (index == intel_dp->drrs_state.refresh_rate_type) {
  4372.                 DRM_DEBUG_KMS(
  4373.                         "DRRS requested for previously set RR...ignoring\n");
  4374.                 return;
  4375.         }
  4376.  
  4377.         if (!intel_crtc->active) {
  4378.                 DRM_DEBUG_KMS("eDP encoder disabled. CRTC not Active\n");
  4379.                 return;
  4380.         }
  4381.  
  4382.         if (INTEL_INFO(dev)->gen > 6 && INTEL_INFO(dev)->gen < 8) {
  4383.                 reg = PIPECONF(intel_crtc->config.cpu_transcoder);
  4384.                 val = I915_READ(reg);
  4385.                 if (index > DRRS_HIGH_RR) {
  4386.                         val |= PIPECONF_EDP_RR_MODE_SWITCH;
  4387.                         intel_dp_set_m2_n2(intel_crtc, &config->dp_m2_n2);
  4388.                 } else {
  4389.                         val &= ~PIPECONF_EDP_RR_MODE_SWITCH;
  4390.                 }
  4391.                 I915_WRITE(reg, val);
  4392.         }
  4393.  
  4394.         /*
  4395.          * mutex taken to ensure that there is no race between differnt
  4396.          * drrs calls trying to update refresh rate. This scenario may occur
  4397.          * in future when idleness detection based DRRS in kernel and
  4398.          * possible calls from user space to set differnt RR are made.
  4399.          */
  4400.  
  4401.         mutex_lock(&intel_dp->drrs_state.mutex);
  4402.  
  4403.         intel_dp->drrs_state.refresh_rate_type = index;
  4404.  
  4405.         mutex_unlock(&intel_dp->drrs_state.mutex);
  4406.  
  4407.         DRM_DEBUG_KMS("eDP Refresh Rate set to : %dHz\n", refresh_rate);
  4408. }
  4409.  
  4410. static struct drm_display_mode *
  4411. intel_dp_drrs_init(struct intel_digital_port *intel_dig_port,
  4412.                         struct intel_connector *intel_connector,
  4413.                         struct drm_display_mode *fixed_mode)
  4414. {
  4415.         struct drm_connector *connector = &intel_connector->base;
  4416.         struct intel_dp *intel_dp = &intel_dig_port->dp;
  4417.         struct drm_device *dev = intel_dig_port->base.base.dev;
  4418.         struct drm_i915_private *dev_priv = dev->dev_private;
  4419.         struct drm_display_mode *downclock_mode = NULL;
  4420.  
  4421.         if (INTEL_INFO(dev)->gen <= 6) {
  4422.                 DRM_DEBUG_KMS("DRRS supported for Gen7 and above\n");
  4423.                 return NULL;
  4424.         }
  4425.  
  4426.         if (dev_priv->vbt.drrs_type != SEAMLESS_DRRS_SUPPORT) {
  4427.                 DRM_INFO("VBT doesn't support DRRS\n");
  4428.                 return NULL;
  4429.         }
  4430.  
  4431.         downclock_mode = intel_find_panel_downclock
  4432.                                         (dev, fixed_mode, connector);
  4433.  
  4434.         if (!downclock_mode) {
  4435.                 DRM_INFO("DRRS not supported\n");
  4436.                 return NULL;
  4437.         }
  4438.  
  4439.         dev_priv->drrs.connector = intel_connector;
  4440.  
  4441.         mutex_init(&intel_dp->drrs_state.mutex);
  4442.  
  4443.         intel_dp->drrs_state.type = dev_priv->vbt.drrs_type;
  4444.  
  4445.         intel_dp->drrs_state.refresh_rate_type = DRRS_HIGH_RR;
  4446.         DRM_INFO("seamless DRRS supported for eDP panel.\n");
  4447.         return downclock_mode;
  4448. }
  4449.  
  4450. void intel_edp_panel_vdd_sanitize(struct intel_encoder *intel_encoder)
  4451. {
  4452.         struct drm_device *dev = intel_encoder->base.dev;
  4453.         struct drm_i915_private *dev_priv = dev->dev_private;
  4454.         struct intel_dp *intel_dp;
  4455.         enum intel_display_power_domain power_domain;
  4456.  
  4457.         if (intel_encoder->type != INTEL_OUTPUT_EDP)
  4458.                 return;
  4459.  
  4460.         intel_dp = enc_to_intel_dp(&intel_encoder->base);
  4461.         if (!edp_have_panel_vdd(intel_dp))
  4462.                 return;
  4463.         /*
  4464.          * The VDD bit needs a power domain reference, so if the bit is
  4465.          * already enabled when we boot or resume, grab this reference and
  4466.          * schedule a vdd off, so we don't hold on to the reference
  4467.          * indefinitely.
  4468.          */
  4469.         DRM_DEBUG_KMS("VDD left on by BIOS, adjusting state tracking\n");
  4470.         power_domain = intel_display_port_power_domain(intel_encoder);
  4471.         intel_display_power_get(dev_priv, power_domain);
  4472.  
  4473.         edp_panel_vdd_schedule_off(intel_dp);
  4474. }
  4475.  
  4476. static bool intel_edp_init_connector(struct intel_dp *intel_dp,
  4477.                                      struct intel_connector *intel_connector,
  4478.                                      struct edp_power_seq *power_seq)
  4479. {
  4480.         struct drm_connector *connector = &intel_connector->base;
  4481.         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
  4482.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  4483.         struct drm_device *dev = intel_encoder->base.dev;
  4484.         struct drm_i915_private *dev_priv = dev->dev_private;
  4485.         struct drm_display_mode *fixed_mode = NULL;
  4486.         struct drm_display_mode *downclock_mode = NULL;
  4487.         bool has_dpcd;
  4488.         struct drm_display_mode *scan;
  4489.         struct edid *edid;
  4490.  
  4491.         intel_dp->drrs_state.type = DRRS_NOT_SUPPORTED;
  4492.  
  4493.         if (!is_edp(intel_dp))
  4494.                 return true;
  4495.  
  4496.         intel_edp_panel_vdd_sanitize(intel_encoder);
  4497.  
  4498.         /* Cache DPCD and EDID for edp. */
  4499.         intel_edp_panel_vdd_on(intel_dp);
  4500.         has_dpcd = intel_dp_get_dpcd(intel_dp);
  4501.         edp_panel_vdd_off(intel_dp, false);
  4502.  
  4503.         if (has_dpcd) {
  4504.                 if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11)
  4505.                         dev_priv->no_aux_handshake =
  4506.                                 intel_dp->dpcd[DP_MAX_DOWNSPREAD] &
  4507.                                 DP_NO_AUX_HANDSHAKE_LINK_TRAINING;
  4508.         } else {
  4509.                 /* if this fails, presume the device is a ghost */
  4510.                 DRM_INFO("failed to retrieve link info, disabling eDP\n");
  4511.                 return false;
  4512.         }
  4513.  
  4514.         /* We now know it's not a ghost, init power sequence regs. */
  4515.         intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, power_seq);
  4516.  
  4517.         mutex_lock(&dev->mode_config.mutex);
  4518.         edid = drm_get_edid(connector, &intel_dp->aux.ddc);
  4519.         if (edid) {
  4520.                 if (drm_add_edid_modes(connector, edid)) {
  4521.                         drm_mode_connector_update_edid_property(connector,
  4522.                                                                 edid);
  4523.                         drm_edid_to_eld(connector, edid);
  4524.                 } else {
  4525.                         kfree(edid);
  4526.                         edid = ERR_PTR(-EINVAL);
  4527.                 }
  4528.         } else {
  4529.                 edid = ERR_PTR(-ENOENT);
  4530.         }
  4531.         intel_connector->edid = edid;
  4532.  
  4533.         /* prefer fixed mode from EDID if available */
  4534.         list_for_each_entry(scan, &connector->probed_modes, head) {
  4535.                 if ((scan->type & DRM_MODE_TYPE_PREFERRED)) {
  4536.                         fixed_mode = drm_mode_duplicate(dev, scan);
  4537.                         downclock_mode = intel_dp_drrs_init(
  4538.                                                 intel_dig_port,
  4539.                                                 intel_connector, fixed_mode);
  4540.                         break;
  4541.                 }
  4542.         }
  4543.  
  4544.         /* fallback to VBT if available for eDP */
  4545.         if (!fixed_mode && dev_priv->vbt.lfp_lvds_vbt_mode) {
  4546.                 fixed_mode = drm_mode_duplicate(dev,
  4547.                                         dev_priv->vbt.lfp_lvds_vbt_mode);
  4548.                 if (fixed_mode)
  4549.                         fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
  4550.         }
  4551.         mutex_unlock(&dev->mode_config.mutex);
  4552.  
  4553.         intel_panel_init(&intel_connector->panel, fixed_mode, downclock_mode);
  4554.         intel_panel_setup_backlight(connector);
  4555.  
  4556.         return true;
  4557. }
  4558.  
  4559. bool
  4560. intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
  4561.                         struct intel_connector *intel_connector)
  4562. {
  4563.         struct drm_connector *connector = &intel_connector->base;
  4564.         struct intel_dp *intel_dp = &intel_dig_port->dp;
  4565.         struct intel_encoder *intel_encoder = &intel_dig_port->base;
  4566.         struct drm_device *dev = intel_encoder->base.dev;
  4567.         struct drm_i915_private *dev_priv = dev->dev_private;
  4568.         enum port port = intel_dig_port->port;
  4569.         struct edp_power_seq power_seq = { 0 };
  4570.         int type;
  4571.  
  4572.         /* intel_dp vfuncs */
  4573.         if (IS_VALLEYVIEW(dev))
  4574.                 intel_dp->get_aux_clock_divider = vlv_get_aux_clock_divider;
  4575.         else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
  4576.                 intel_dp->get_aux_clock_divider = hsw_get_aux_clock_divider;
  4577.         else if (HAS_PCH_SPLIT(dev))
  4578.                 intel_dp->get_aux_clock_divider = ilk_get_aux_clock_divider;
  4579.         else
  4580.                 intel_dp->get_aux_clock_divider = i9xx_get_aux_clock_divider;
  4581.  
  4582.         intel_dp->get_aux_send_ctl = i9xx_get_aux_send_ctl;
  4583.  
  4584.         /* Preserve the current hw state. */
  4585.         intel_dp->DP = I915_READ(intel_dp->output_reg);
  4586.         intel_dp->attached_connector = intel_connector;
  4587.  
  4588.         if (intel_dp_is_edp(dev, port))
  4589.                 type = DRM_MODE_CONNECTOR_eDP;
  4590.         else
  4591.         type = DRM_MODE_CONNECTOR_DisplayPort;
  4592.  
  4593.         /*
  4594.          * For eDP we always set the encoder type to INTEL_OUTPUT_EDP, but
  4595.          * for DP the encoder type can be set by the caller to
  4596.          * INTEL_OUTPUT_UNKNOWN for DDI, so don't rewrite it.
  4597.          */
  4598.         if (type == DRM_MODE_CONNECTOR_eDP)
  4599.                 intel_encoder->type = INTEL_OUTPUT_EDP;
  4600.  
  4601.         DRM_DEBUG_KMS("Adding %s connector on port %c\n",
  4602.                         type == DRM_MODE_CONNECTOR_eDP ? "eDP" : "DP",
  4603.                         port_name(port));
  4604.  
  4605.         drm_connector_init(dev, connector, &intel_dp_connector_funcs, type);
  4606.         drm_connector_helper_add(connector, &intel_dp_connector_helper_funcs);
  4607.  
  4608.         connector->interlace_allowed = true;
  4609.         connector->doublescan_allowed = 0;
  4610.  
  4611.         INIT_DELAYED_WORK(&intel_dp->panel_vdd_work,
  4612.                           edp_panel_vdd_work);
  4613.  
  4614.         intel_connector_attach_encoder(intel_connector, intel_encoder);
  4615.         drm_connector_register(connector);
  4616.  
  4617.         if (HAS_DDI(dev))
  4618.                 intel_connector->get_hw_state = intel_ddi_connector_get_hw_state;
  4619.         else
  4620.         intel_connector->get_hw_state = intel_connector_get_hw_state;
  4621.         intel_connector->unregister = intel_dp_connector_unregister;
  4622.  
  4623.         /* Set up the hotplug pin. */
  4624.         switch (port) {
  4625.         case PORT_A:
  4626.                 intel_encoder->hpd_pin = HPD_PORT_A;
  4627.                         break;
  4628.         case PORT_B:
  4629.                 intel_encoder->hpd_pin = HPD_PORT_B;
  4630.                         break;
  4631.         case PORT_C:
  4632.                 intel_encoder->hpd_pin = HPD_PORT_C;
  4633.                         break;
  4634.         case PORT_D:
  4635.                 intel_encoder->hpd_pin = HPD_PORT_D;
  4636.                         break;
  4637.         default:
  4638.                 BUG();
  4639.         }
  4640.  
  4641.         if (is_edp(intel_dp)) {
  4642.                 intel_dp_init_panel_power_timestamps(intel_dp);
  4643.                 intel_dp_init_panel_power_sequencer(dev, intel_dp, &power_seq);
  4644.         }
  4645.  
  4646.         intel_dp_aux_init(intel_dp, intel_connector);
  4647.  
  4648.         /* init MST on ports that can support it */
  4649.         if (IS_HASWELL(dev) || IS_BROADWELL(dev)) {
  4650.                 if (port == PORT_B || port == PORT_C || port == PORT_D) {
  4651.                         intel_dp_mst_encoder_init(intel_dig_port, intel_connector->base.base.id);
  4652.                 }
  4653.         }
  4654.  
  4655.         if (!intel_edp_init_connector(intel_dp, intel_connector, &power_seq)) {
  4656.                 drm_dp_aux_unregister(&intel_dp->aux);
  4657.         if (is_edp(intel_dp)) {
  4658.                         cancel_delayed_work_sync(&intel_dp->panel_vdd_work);
  4659.                         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
  4660.                         edp_panel_vdd_off_sync(intel_dp);
  4661.                         drm_modeset_unlock(&dev->mode_config.connection_mutex);
  4662.                 }
  4663.                 drm_connector_unregister(connector);
  4664.                 drm_connector_cleanup(connector);
  4665.                 return false;
  4666.         }
  4667.  
  4668.         intel_dp_add_properties(intel_dp, connector);
  4669.  
  4670.         /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
  4671.          * 0xd.  Failure to do so will result in spurious interrupts being
  4672.          * generated on the port when a cable is not attached.
  4673.          */
  4674.         if (IS_G4X(dev) && !IS_GM45(dev)) {
  4675.                 u32 temp = I915_READ(PEG_BAND_GAP_DATA);
  4676.                 I915_WRITE(PEG_BAND_GAP_DATA, (temp & ~0xf) | 0xd);
  4677.         }
  4678.  
  4679.         return true;
  4680. }
  4681.  
  4682. void
  4683. intel_dp_init(struct drm_device *dev, int output_reg, enum port port)
  4684. {
  4685.         struct drm_i915_private *dev_priv = dev->dev_private;
  4686.         struct intel_digital_port *intel_dig_port;
  4687.         struct intel_encoder *intel_encoder;
  4688.         struct drm_encoder *encoder;
  4689.         struct intel_connector *intel_connector;
  4690.  
  4691.         intel_dig_port = kzalloc(sizeof(*intel_dig_port), GFP_KERNEL);
  4692.         if (!intel_dig_port)
  4693.                 return;
  4694.  
  4695.         intel_connector = kzalloc(sizeof(*intel_connector), GFP_KERNEL);
  4696.         if (!intel_connector) {
  4697.                 kfree(intel_dig_port);
  4698.                 return;
  4699.         }
  4700.  
  4701.         intel_encoder = &intel_dig_port->base;
  4702.         encoder = &intel_encoder->base;
  4703.  
  4704.         drm_encoder_init(dev, &intel_encoder->base, &intel_dp_enc_funcs,
  4705.                          DRM_MODE_ENCODER_TMDS);
  4706.  
  4707.         intel_encoder->compute_config = intel_dp_compute_config;
  4708.         intel_encoder->disable = intel_disable_dp;
  4709.         intel_encoder->get_hw_state = intel_dp_get_hw_state;
  4710.         intel_encoder->get_config = intel_dp_get_config;
  4711.         intel_encoder->suspend = intel_dp_encoder_suspend;
  4712.         if (IS_CHERRYVIEW(dev)) {
  4713.                 intel_encoder->pre_pll_enable = chv_dp_pre_pll_enable;
  4714.                 intel_encoder->pre_enable = chv_pre_enable_dp;
  4715.                 intel_encoder->enable = vlv_enable_dp;
  4716.                 intel_encoder->post_disable = chv_post_disable_dp;
  4717.         } else if (IS_VALLEYVIEW(dev)) {
  4718.                 intel_encoder->pre_pll_enable = vlv_dp_pre_pll_enable;
  4719.                 intel_encoder->pre_enable = vlv_pre_enable_dp;
  4720.                 intel_encoder->enable = vlv_enable_dp;
  4721.                 intel_encoder->post_disable = vlv_post_disable_dp;
  4722.         } else {
  4723.                 intel_encoder->pre_enable = g4x_pre_enable_dp;
  4724.                 intel_encoder->enable = g4x_enable_dp;
  4725.                 intel_encoder->post_disable = g4x_post_disable_dp;
  4726.         }
  4727.  
  4728.         intel_dig_port->port = port;
  4729.         intel_dig_port->dp.output_reg = output_reg;
  4730.  
  4731.         intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT;
  4732.         if (IS_CHERRYVIEW(dev)) {
  4733.                 if (port == PORT_D)
  4734.                         intel_encoder->crtc_mask = 1 << 2;
  4735.                 else
  4736.                         intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
  4737.         } else {
  4738.         intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
  4739.         }
  4740.         intel_encoder->cloneable = 0;
  4741.         intel_encoder->hot_plug = intel_dp_hot_plug;
  4742.  
  4743.         intel_dig_port->hpd_pulse = intel_dp_hpd_pulse;
  4744.         dev_priv->hpd_irq_port[port] = intel_dig_port;
  4745.  
  4746.         if (!intel_dp_init_connector(intel_dig_port, intel_connector)) {
  4747.                 drm_encoder_cleanup(encoder);
  4748.                 kfree(intel_dig_port);
  4749.                 kfree(intel_connector);
  4750.         }
  4751. }
  4752.  
  4753. void intel_dp_mst_suspend(struct drm_device *dev)
  4754. {
  4755.         struct drm_i915_private *dev_priv = dev->dev_private;
  4756.         int i;
  4757.  
  4758.         /* disable MST */
  4759.         for (i = 0; i < I915_MAX_PORTS; i++) {
  4760.                 struct intel_digital_port *intel_dig_port = dev_priv->hpd_irq_port[i];
  4761.                 if (!intel_dig_port)
  4762.                         continue;
  4763.  
  4764.                 if (intel_dig_port->base.type == INTEL_OUTPUT_DISPLAYPORT) {
  4765.                         if (!intel_dig_port->dp.can_mst)
  4766.                                 continue;
  4767.                         if (intel_dig_port->dp.is_mst)
  4768.                                 drm_dp_mst_topology_mgr_suspend(&intel_dig_port->dp.mst_mgr);
  4769.                 }
  4770.         }
  4771. }
  4772.  
  4773. void intel_dp_mst_resume(struct drm_device *dev)
  4774. {
  4775.         struct drm_i915_private *dev_priv = dev->dev_private;
  4776.         int i;
  4777.  
  4778.         for (i = 0; i < I915_MAX_PORTS; i++) {
  4779.                 struct intel_digital_port *intel_dig_port = dev_priv->hpd_irq_port[i];
  4780.                 if (!intel_dig_port)
  4781.                         continue;
  4782.                 if (intel_dig_port->base.type == INTEL_OUTPUT_DISPLAYPORT) {
  4783.                         int ret;
  4784.  
  4785.                         if (!intel_dig_port->dp.can_mst)
  4786.                                 continue;
  4787.  
  4788.                         ret = drm_dp_mst_topology_mgr_resume(&intel_dig_port->dp.mst_mgr);
  4789.                         if (ret != 0) {
  4790.                                 intel_dp_check_mst_status(&intel_dig_port->dp);
  4791.                         }
  4792.                 }
  4793.         }
  4794. }
  4795.