Rev 5354 | Rev 6937 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 5354 | Rev 6084 | ||
---|---|---|---|
Line 59... | Line 59... | ||
59 | static bool is_edp_psr(struct intel_dp *intel_dp) |
59 | static bool is_edp_psr(struct intel_dp *intel_dp) |
60 | { |
60 | { |
61 | return intel_dp->psr_dpcd[0] & DP_PSR_IS_SUPPORTED; |
61 | return intel_dp->psr_dpcd[0] & DP_PSR_IS_SUPPORTED; |
62 | } |
62 | } |
Line 63... | Line 63... | ||
63 | 63 | ||
64 | bool intel_psr_is_enabled(struct drm_device *dev) |
64 | static bool vlv_is_psr_active_on_pipe(struct drm_device *dev, int pipe) |
65 | { |
65 | { |
- | 66 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
Line 66... | Line 67... | ||
66 | struct drm_i915_private *dev_priv = dev->dev_private; |
67 | uint32_t val; |
- | 68 | ||
67 | 69 | val = I915_READ(VLV_PSRSTAT(pipe)) & |
|
68 | if (!HAS_PSR(dev)) |
- | |
69 | return false; |
70 | VLV_EDP_PSR_CURR_STATE_MASK; |
70 | 71 | return (val == VLV_EDP_PSR_ACTIVE_NORFB_UP) || |
|
Line 71... | Line 72... | ||
71 | return I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE; |
72 | (val == VLV_EDP_PSR_ACTIVE_SF_UPDATE); |
72 | } |
73 | } |
73 | 74 | ||
74 | static void intel_psr_write_vsc(struct intel_dp *intel_dp, |
75 | static void intel_psr_write_vsc(struct intel_dp *intel_dp, |
75 | struct edp_vsc_psr *vsc_psr) |
76 | const struct edp_vsc_psr *vsc_psr) |
76 | { |
77 | { |
77 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
78 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
78 | struct drm_device *dev = dig_port->base.base.dev; |
79 | struct drm_device *dev = dig_port->base.base.dev; |
79 | struct drm_i915_private *dev_priv = dev->dev_private; |
80 | struct drm_i915_private *dev_priv = dev->dev_private; |
80 | struct intel_crtc *crtc = to_intel_crtc(dig_port->base.base.crtc); |
81 | struct intel_crtc *crtc = to_intel_crtc(dig_port->base.base.crtc); |
81 | u32 ctl_reg = HSW_TVIDEO_DIP_CTL(crtc->config.cpu_transcoder); |
82 | enum transcoder cpu_transcoder = crtc->config->cpu_transcoder; |
Line 82... | Line 83... | ||
82 | u32 data_reg = HSW_TVIDEO_DIP_VSC_DATA(crtc->config.cpu_transcoder); |
83 | u32 ctl_reg = HSW_TVIDEO_DIP_CTL(cpu_transcoder); |
83 | uint32_t *data = (uint32_t *) vsc_psr; |
84 | uint32_t *data = (uint32_t *) vsc_psr; |
84 | unsigned int i; |
85 | unsigned int i; |
85 | 86 | ||
86 | /* As per BSPec (Pipe Video Data Island Packet), we need to disable |
87 | /* As per BSPec (Pipe Video Data Island Packet), we need to disable |
Line 87... | Line 88... | ||
87 | the video DIP being updated before program video DIP data buffer |
88 | the video DIP being updated before program video DIP data buffer |
88 | registers for DIP being updated. */ |
89 | registers for DIP being updated. */ |
89 | I915_WRITE(ctl_reg, 0); |
90 | I915_WRITE(ctl_reg, 0); |
90 | POSTING_READ(ctl_reg); |
91 | POSTING_READ(ctl_reg); |
91 | - | ||
92 | for (i = 0; i < VIDEO_DIP_VSC_DATA_SIZE; i += 4) { |
92 | |
- | 93 | for (i = 0; i < sizeof(*vsc_psr); i += 4) { |
|
- | 94 | I915_WRITE(HSW_TVIDEO_DIP_VSC_DATA(cpu_transcoder, |
|
- | 95 | i >> 2), *data); |
|
Line 93... | Line 96... | ||
93 | if (i < sizeof(struct edp_vsc_psr)) |
96 | data++; |
94 | I915_WRITE(data_reg + i, *data++); |
97 | } |
95 | else |
98 | for (; i < VIDEO_DIP_VSC_DATA_SIZE; i += 4) |
Line 96... | Line 99... | ||
96 | I915_WRITE(data_reg + i, 0); |
99 | I915_WRITE(HSW_TVIDEO_DIP_VSC_DATA(cpu_transcoder, |
- | 100 | i >> 2), 0); |
|
- | 101 | ||
- | 102 | I915_WRITE(ctl_reg, VIDEO_DIP_ENABLE_VSC_HSW); |
|
- | 103 | POSTING_READ(ctl_reg); |
|
- | 104 | } |
|
- | 105 | ||
- | 106 | static void vlv_psr_setup_vsc(struct intel_dp *intel_dp) |
|
- | 107 | { |
|
- | 108 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
|
- | 109 | struct drm_device *dev = intel_dig_port->base.base.dev; |
|
- | 110 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 111 | struct drm_crtc *crtc = intel_dig_port->base.base.crtc; |
|
- | 112 | enum pipe pipe = to_intel_crtc(crtc)->pipe; |
|
- | 113 | uint32_t val; |
|
- | 114 | ||
- | 115 | /* VLV auto-generate VSC package as per EDP 1.3 spec, Table 3.10 */ |
|
- | 116 | val = I915_READ(VLV_VSCSDP(pipe)); |
|
- | 117 | val &= ~VLV_EDP_PSR_SDP_FREQ_MASK; |
|
- | 118 | val |= VLV_EDP_PSR_SDP_FREQ_EVFRAME; |
|
- | 119 | I915_WRITE(VLV_VSCSDP(pipe), val); |
|
- | 120 | } |
|
- | 121 | ||
- | 122 | static void skl_psr_setup_su_vsc(struct intel_dp *intel_dp) |
|
- | 123 | { |
|
- | 124 | struct edp_vsc_psr psr_vsc; |
|
- | 125 | ||
- | 126 | /* Prepare VSC Header for SU as per EDP 1.4 spec, Table 6.11 */ |
|
- | 127 | memset(&psr_vsc, 0, sizeof(psr_vsc)); |
|
- | 128 | psr_vsc.sdp_header.HB0 = 0; |
|
97 | } |
129 | psr_vsc.sdp_header.HB1 = 0x7; |
98 | 130 | psr_vsc.sdp_header.HB2 = 0x3; |
|
Line 99... | Line 131... | ||
99 | I915_WRITE(ctl_reg, VIDEO_DIP_ENABLE_VSC_HSW); |
131 | psr_vsc.sdp_header.HB3 = 0xb; |
100 | POSTING_READ(ctl_reg); |
132 | intel_psr_write_vsc(intel_dp, &psr_vsc); |
Line 111... | Line 143... | ||
111 | psr_vsc.sdp_header.HB2 = 0x2; |
143 | psr_vsc.sdp_header.HB2 = 0x2; |
112 | psr_vsc.sdp_header.HB3 = 0x8; |
144 | psr_vsc.sdp_header.HB3 = 0x8; |
113 | intel_psr_write_vsc(intel_dp, &psr_vsc); |
145 | intel_psr_write_vsc(intel_dp, &psr_vsc); |
114 | } |
146 | } |
Line 115... | Line 147... | ||
115 | 147 | ||
- | 148 | static void vlv_psr_enable_sink(struct intel_dp *intel_dp) |
|
- | 149 | { |
|
- | 150 | drm_dp_dpcd_writeb(&intel_dp->aux, DP_PSR_EN_CFG, |
|
- | 151 | DP_PSR_ENABLE | DP_PSR_MAIN_LINK_ACTIVE); |
|
- | 152 | } |
|
- | 153 | ||
116 | static void intel_psr_enable_sink(struct intel_dp *intel_dp) |
154 | static void hsw_psr_enable_sink(struct intel_dp *intel_dp) |
117 | { |
155 | { |
118 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
156 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
119 | struct drm_device *dev = dig_port->base.base.dev; |
157 | struct drm_device *dev = dig_port->base.base.dev; |
120 | struct drm_i915_private *dev_priv = dev->dev_private; |
158 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | 159 | uint32_t aux_clock_divider; |
|
121 | uint32_t aux_clock_divider; |
160 | uint32_t aux_data_reg, aux_ctl_reg; |
122 | int precharge = 0x3; |
- | |
123 | bool only_standby = false; |
161 | int precharge = 0x3; |
124 | static const uint8_t aux_msg[] = { |
162 | static const uint8_t aux_msg[] = { |
125 | [0] = DP_AUX_NATIVE_WRITE << 4, |
163 | [0] = DP_AUX_NATIVE_WRITE << 4, |
126 | [1] = DP_SET_POWER >> 8, |
164 | [1] = DP_SET_POWER >> 8, |
127 | [2] = DP_SET_POWER & 0xff, |
165 | [2] = DP_SET_POWER & 0xff, |
Line 132... | Line 170... | ||
132 | 170 | ||
Line 133... | Line 171... | ||
133 | BUILD_BUG_ON(sizeof(aux_msg) > 20); |
171 | BUILD_BUG_ON(sizeof(aux_msg) > 20); |
Line 134... | Line -... | ||
134 | - | ||
135 | aux_clock_divider = intel_dp->get_aux_clock_divider(intel_dp, 0); |
- | |
136 | - | ||
137 | if (IS_BROADWELL(dev) && dig_port->port != PORT_A) |
- | |
138 | only_standby = true; |
- | |
139 | 172 | ||
140 | /* Enable PSR in sink */ |
173 | aux_clock_divider = intel_dp->get_aux_clock_divider(intel_dp, 0); |
141 | if (intel_dp->psr_dpcd[1] & DP_PSR_NO_TRAIN_ON_EXIT || only_standby) |
174 | |
- | 175 | drm_dp_dpcd_writeb(&intel_dp->aux, DP_PSR_EN_CFG, |
|
- | 176 | DP_PSR_ENABLE & ~DP_PSR_MAIN_LINK_ACTIVE); |
|
142 | drm_dp_dpcd_writeb(&intel_dp->aux, DP_PSR_EN_CFG, |
177 | |
- | 178 | /* Enable AUX frame sync at sink */ |
|
- | 179 | if (dev_priv->psr.aux_frame_sync) |
|
- | 180 | drm_dp_dpcd_writeb(&intel_dp->aux, |
|
- | 181 | DP_SINK_DEVICE_AUX_FRAME_SYNC_CONF, |
|
143 | DP_PSR_ENABLE & ~DP_PSR_MAIN_LINK_ACTIVE); |
182 | DP_AUX_FRAME_SYNC_ENABLE); |
- | 183 | ||
- | 184 | aux_data_reg = (INTEL_INFO(dev)->gen >= 9) ? |
|
Line 144... | Line 185... | ||
144 | else |
185 | DPA_AUX_CH_DATA1 : EDP_PSR_AUX_DATA1(dev); |
145 | drm_dp_dpcd_writeb(&intel_dp->aux, DP_PSR_EN_CFG, |
186 | aux_ctl_reg = (INTEL_INFO(dev)->gen >= 9) ? |
146 | DP_PSR_ENABLE | DP_PSR_MAIN_LINK_ACTIVE); |
187 | DPA_AUX_CH_CTL : EDP_PSR_AUX_CTL(dev); |
147 | 188 | ||
Line -... | Line 189... | ||
- | 189 | /* Setup AUX registers */ |
|
- | 190 | for (i = 0; i < sizeof(aux_msg); i += 4) |
|
- | 191 | I915_WRITE(aux_data_reg + i, |
|
- | 192 | intel_dp_pack_aux(&aux_msg[i], sizeof(aux_msg) - i)); |
|
- | 193 | ||
- | 194 | if (INTEL_INFO(dev)->gen >= 9) { |
|
- | 195 | uint32_t val; |
|
- | 196 | ||
- | 197 | val = I915_READ(aux_ctl_reg); |
|
- | 198 | val &= ~DP_AUX_CH_CTL_TIME_OUT_MASK; |
|
- | 199 | val |= DP_AUX_CH_CTL_TIME_OUT_1600us; |
|
- | 200 | val &= ~DP_AUX_CH_CTL_MESSAGE_SIZE_MASK; |
|
148 | /* Setup AUX registers */ |
201 | val |= (sizeof(aux_msg) << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT); |
- | 202 | /* Use hardcoded data values for PSR, frame sync and GTC */ |
|
- | 203 | val &= ~DP_AUX_CH_CTL_PSR_DATA_AUX_REG_SKL; |
|
149 | for (i = 0; i < sizeof(aux_msg); i += 4) |
204 | val &= ~DP_AUX_CH_CTL_FS_DATA_AUX_REG_SKL; |
150 | I915_WRITE(EDP_PSR_AUX_DATA1(dev) + i, |
205 | val &= ~DP_AUX_CH_CTL_GTC_DATA_AUX_REG_SKL; |
151 | intel_dp_pack_aux(&aux_msg[i], sizeof(aux_msg) - i)); |
206 | I915_WRITE(aux_ctl_reg, val); |
152 | 207 | } else { |
|
153 | I915_WRITE(EDP_PSR_AUX_CTL(dev), |
208 | I915_WRITE(aux_ctl_reg, |
Line -... | Line 209... | ||
- | 209 | DP_AUX_CH_CTL_TIME_OUT_400us | |
|
- | 210 | (sizeof(aux_msg) << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) | |
|
- | 211 | (precharge << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) | |
|
154 | DP_AUX_CH_CTL_TIME_OUT_400us | |
212 | (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT)); |
- | 213 | } |
|
- | 214 | ||
- | 215 | drm_dp_dpcd_writeb(&intel_dp->aux, DP_PSR_EN_CFG, DP_PSR_ENABLE); |
|
- | 216 | } |
|
- | 217 | ||
- | 218 | static void vlv_psr_enable_source(struct intel_dp *intel_dp) |
|
- | 219 | { |
|
- | 220 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
|
- | 221 | struct drm_device *dev = dig_port->base.base.dev; |
|
- | 222 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 223 | struct drm_crtc *crtc = dig_port->base.base.crtc; |
|
- | 224 | enum pipe pipe = to_intel_crtc(crtc)->pipe; |
|
- | 225 | ||
- | 226 | /* Transition from PSR_state 0 to PSR_state 1, i.e. PSR Inactive */ |
|
- | 227 | I915_WRITE(VLV_PSRCTL(pipe), |
|
- | 228 | VLV_EDP_PSR_MODE_SW_TIMER | |
|
- | 229 | VLV_EDP_PSR_SRC_TRANSMITTER_STATE | |
|
- | 230 | VLV_EDP_PSR_ENABLE); |
|
- | 231 | } |
|
- | 232 | ||
- | 233 | static void vlv_psr_activate(struct intel_dp *intel_dp) |
|
- | 234 | { |
|
- | 235 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
|
- | 236 | struct drm_device *dev = dig_port->base.base.dev; |
|
- | 237 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 238 | struct drm_crtc *crtc = dig_port->base.base.crtc; |
|
- | 239 | enum pipe pipe = to_intel_crtc(crtc)->pipe; |
|
- | 240 | ||
- | 241 | /* Let's do the transition from PSR_state 1 to PSR_state 2 |
|
- | 242 | * that is PSR transition to active - static frame transmission. |
|
- | 243 | * Then Hardware is responsible for the transition to PSR_state 3 |
|
- | 244 | * that is PSR active - no Remote Frame Buffer (RFB) update. |
|
155 | (sizeof(aux_msg) << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) | |
245 | */ |
156 | (precharge << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) | |
246 | I915_WRITE(VLV_PSRCTL(pipe), I915_READ(VLV_PSRCTL(pipe)) | |
157 | (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT)); |
247 | VLV_EDP_PSR_ACTIVE_ENTRY); |
158 | } |
248 | } |
- | 249 | ||
159 | 250 | static void hsw_psr_enable_source(struct intel_dp *intel_dp) |
|
- | 251 | { |
|
- | 252 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
|
- | 253 | struct drm_device *dev = dig_port->base.base.dev; |
|
- | 254 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 255 | ||
- | 256 | uint32_t max_sleep_time = 0x1f; |
|
- | 257 | /* Lately it was identified that depending on panel idle frame count |
|
160 | static void intel_psr_enable_source(struct intel_dp *intel_dp) |
258 | * calculated at HW can be off by 1. So let's use what came |
- | 259 | * from VBT + 1. |
|
161 | { |
260 | * There are also other cases where panel demands at least 4 |
162 | struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); |
261 | * but VBT is not being set. To cover these 2 cases lets use |
163 | struct drm_device *dev = dig_port->base.base.dev; |
- | |
164 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
165 | uint32_t max_sleep_time = 0x1f; |
- | |
166 | uint32_t idle_frames = 1; |
- | |
Line 167... | Line 262... | ||
167 | uint32_t val = 0x0; |
262 | * at least 5 when VBT isn't set to be on the safest side. |
- | 263 | */ |
|
- | 264 | uint32_t idle_frames = dev_priv->vbt.psr.idle_frames ? |
|
168 | const uint32_t link_entry_time = EDP_PSR_MIN_LINK_ENTRY_TIME_8_LINES; |
265 | dev_priv->vbt.psr.idle_frames + 1 : 5; |
169 | bool only_standby = false; |
266 | uint32_t val = 0x0; |
170 | - | ||
171 | if (IS_BROADWELL(dev) && dig_port->port != PORT_A) |
267 | const uint32_t link_entry_time = EDP_PSR_MIN_LINK_ENTRY_TIME_8_LINES; |
172 | only_standby = true; |
268 | |
- | 269 | if (intel_dp->psr_dpcd[1] & DP_PSR_NO_TRAIN_ON_EXIT) { |
|
173 | 270 | /* It doesn't mean we shouldn't send TPS patters, so let's |
|
174 | if (intel_dp->psr_dpcd[1] & DP_PSR_NO_TRAIN_ON_EXIT || only_standby) { |
- | |
Line 175... | Line 271... | ||
175 | val |= EDP_PSR_LINK_STANDBY; |
271 | send the minimal TP1 possible and skip TP2. */ |
176 | val |= EDP_PSR_TP2_TP3_TIME_0us; |
272 | val |= EDP_PSR_TP1_TIME_100us; |
177 | val |= EDP_PSR_TP1_TIME_0us; |
273 | val |= EDP_PSR_TP2_TP3_TIME_0us; |
178 | val |= EDP_PSR_SKIP_AUX_EXIT; |
274 | val |= EDP_PSR_SKIP_AUX_EXIT; |
179 | val |= IS_BROADWELL(dev) ? BDW_PSR_SINGLE_FRAME : 0; |
275 | /* Sink should be able to train with the 5 or 6 idle patterns */ |
- | 276 | idle_frames += 4; |
|
- | 277 | } |
|
- | 278 | ||
- | 279 | I915_WRITE(EDP_PSR_CTL(dev), val | |
|
180 | } else |
280 | (IS_BROADWELL(dev) ? 0 : link_entry_time) | |
Line 181... | Line 281... | ||
181 | val |= EDP_PSR_LINK_DISABLE; |
281 | max_sleep_time << EDP_PSR_MAX_SLEEP_TIME_SHIFT | |
182 | 282 | idle_frames << EDP_PSR_IDLE_FRAME_SHIFT | |
|
183 | I915_WRITE(EDP_PSR_CTL(dev), val | |
283 | EDP_PSR_ENABLE); |
Line 209... | Line 309... | ||
209 | if (!i915.enable_psr) { |
309 | if (!i915.enable_psr) { |
210 | DRM_DEBUG_KMS("PSR disable by flag\n"); |
310 | DRM_DEBUG_KMS("PSR disable by flag\n"); |
211 | return false; |
311 | return false; |
212 | } |
312 | } |
Line 213... | Line -... | ||
213 | - | ||
214 | /* Below limitations aren't valid for Broadwell */ |
313 | |
215 | if (IS_BROADWELL(dev)) |
- | |
216 | goto out; |
- | |
217 | 314 | if (IS_HASWELL(dev) && |
|
218 | if (I915_READ(HSW_STEREO_3D_CTL(intel_crtc->config.cpu_transcoder)) & |
315 | I915_READ(HSW_STEREO_3D_CTL(intel_crtc->config->cpu_transcoder)) & |
219 | S3D_ENABLE) { |
316 | S3D_ENABLE) { |
220 | DRM_DEBUG_KMS("PSR condition failed: Stereo 3D is Enabled\n"); |
317 | DRM_DEBUG_KMS("PSR condition failed: Stereo 3D is Enabled\n"); |
221 | return false; |
318 | return false; |
Line -... | Line 319... | ||
- | 319 | } |
|
222 | } |
320 | |
223 | 321 | if (IS_HASWELL(dev) && |
|
224 | if (intel_crtc->config.adjusted_mode.flags & DRM_MODE_FLAG_INTERLACE) { |
322 | intel_crtc->config->base.adjusted_mode.flags & DRM_MODE_FLAG_INTERLACE) { |
225 | DRM_DEBUG_KMS("PSR condition failed: Interlaced is Enabled\n"); |
323 | DRM_DEBUG_KMS("PSR condition failed: Interlaced is Enabled\n"); |
Line -... | Line 324... | ||
- | 324 | return false; |
|
- | 325 | } |
|
- | 326 | ||
- | 327 | if (!IS_VALLEYVIEW(dev) && ((dev_priv->vbt.psr.full_link) || |
|
226 | return false; |
328 | (dig_port->port != PORT_A))) { |
- | 329 | DRM_DEBUG_KMS("PSR condition failed: Link Standby requested/needed but not supported on this platform\n"); |
|
227 | } |
330 | return false; |
228 | 331 | } |
|
229 | out: |
332 | |
Line 230... | Line 333... | ||
230 | dev_priv->psr.source_ok = true; |
333 | dev_priv->psr.source_ok = true; |
231 | return true; |
334 | return true; |
232 | } |
335 | } |
233 | 336 | ||
234 | static void intel_psr_do_enable(struct intel_dp *intel_dp) |
337 | static void intel_psr_activate(struct intel_dp *intel_dp) |
Line 235... | Line 338... | ||
235 | { |
338 | { |
236 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
339 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
237 | struct drm_device *dev = intel_dig_port->base.base.dev; |
340 | struct drm_device *dev = intel_dig_port->base.base.dev; |
Line 238... | Line 341... | ||
238 | struct drm_i915_private *dev_priv = dev->dev_private; |
341 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | 342 | ||
- | 343 | WARN_ON(I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE); |
|
- | 344 | WARN_ON(dev_priv->psr.active); |
|
- | 345 | lockdep_assert_held(&dev_priv->psr.lock); |
|
- | 346 | ||
239 | 347 | /* Enable/Re-enable PSR on the host */ |
|
- | 348 | if (HAS_DDI(dev)) |
|
- | 349 | /* On HSW+ after we enable PSR on source it will activate it |
|
Line 240... | Line 350... | ||
240 | WARN_ON(I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE); |
350 | * as soon as it match configure idle_frame count. So |
241 | WARN_ON(dev_priv->psr.active); |
351 | * we just actually enable it here on activation time. |
Line 242... | Line 352... | ||
242 | lockdep_assert_held(&dev_priv->psr.lock); |
352 | */ |
Line 256... | Line 366... | ||
256 | void intel_psr_enable(struct intel_dp *intel_dp) |
366 | void intel_psr_enable(struct intel_dp *intel_dp) |
257 | { |
367 | { |
258 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
368 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
259 | struct drm_device *dev = intel_dig_port->base.base.dev; |
369 | struct drm_device *dev = intel_dig_port->base.base.dev; |
260 | struct drm_i915_private *dev_priv = dev->dev_private; |
370 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | 371 | struct intel_crtc *crtc = to_intel_crtc(intel_dig_port->base.base.crtc); |
|
Line 261... | Line 372... | ||
261 | 372 | ||
262 | if (!HAS_PSR(dev)) { |
373 | if (!HAS_PSR(dev)) { |
263 | DRM_DEBUG_KMS("PSR not supported on this platform\n"); |
374 | DRM_DEBUG_KMS("PSR not supported on this platform\n"); |
264 | return; |
375 | return; |
Line 278... | Line 389... | ||
278 | if (!intel_psr_match_conditions(intel_dp)) |
389 | if (!intel_psr_match_conditions(intel_dp)) |
279 | goto unlock; |
390 | goto unlock; |
Line 280... | Line 391... | ||
280 | 391 | ||
Line -... | Line 392... | ||
- | 392 | dev_priv->psr.busy_frontbuffer_bits = 0; |
|
281 | dev_priv->psr.busy_frontbuffer_bits = 0; |
393 | |
- | 394 | if (HAS_DDI(dev)) { |
|
- | 395 | hsw_psr_setup_vsc(intel_dp); |
|
- | 396 | ||
- | 397 | if (dev_priv->psr.psr2_support) { |
|
- | 398 | /* PSR2 is restricted to work with panel resolutions upto 3200x2000 */ |
|
- | 399 | if (crtc->config->pipe_src_w > 3200 || |
|
- | 400 | crtc->config->pipe_src_h > 2000) |
|
- | 401 | dev_priv->psr.psr2_support = false; |
|
- | 402 | else |
|
Line 282... | Line 403... | ||
282 | 403 | skl_psr_setup_su_vsc(intel_dp); |
|
283 | intel_psr_setup_vsc(intel_dp); |
404 | } |
284 | 405 | ||
Line 285... | Line 406... | ||
285 | /* Avoid continuous PSR exit by masking memup and hpd */ |
406 | /* Avoid continuous PSR exit by masking memup and hpd */ |
286 | I915_WRITE(EDP_PSR_DEBUG_CTL(dev), EDP_PSR_DEBUG_MASK_MEMUP | |
407 | I915_WRITE(EDP_PSR_DEBUG_CTL(dev), EDP_PSR_DEBUG_MASK_MEMUP | |
- | 408 | EDP_PSR_DEBUG_MASK_HPD); |
|
- | 409 | ||
- | 410 | /* Enable PSR on the panel */ |
|
- | 411 | hsw_psr_enable_sink(intel_dp); |
|
- | 412 | ||
- | 413 | if (INTEL_INFO(dev)->gen >= 9) |
|
- | 414 | intel_psr_activate(intel_dp); |
|
- | 415 | } else { |
|
- | 416 | vlv_psr_setup_vsc(intel_dp); |
|
- | 417 | ||
- | 418 | /* Enable PSR on the panel */ |
|
- | 419 | vlv_psr_enable_sink(intel_dp); |
|
- | 420 | ||
- | 421 | /* On HSW+ enable_source also means go to PSR entry/active |
|
- | 422 | * state as soon as idle_frame achieved and here would be |
|
- | 423 | * to soon. However on VLV enable_source just enable PSR |
|
- | 424 | * but let it on inactive state. So we might do this prior |
|
Line 287... | Line 425... | ||
287 | EDP_PSR_DEBUG_MASK_HPD | EDP_PSR_DEBUG_MASK_LPSP); |
425 | * to active transition, i.e. here. |
288 | 426 | */ |
|
289 | /* Enable PSR on the panel */ |
427 | vlv_psr_enable_source(intel_dp); |
290 | intel_psr_enable_sink(intel_dp); |
428 | } |
Line 291... | Line -... | ||
291 | - | ||
292 | dev_priv->psr.enabled = intel_dp; |
- | |
293 | unlock: |
- | |
294 | mutex_unlock(&dev_priv->psr.lock); |
- | |
295 | } |
- | |
296 | - | ||
297 | /** |
429 | |
298 | * intel_psr_disable - Disable PSR |
430 | dev_priv->psr.enabled = intel_dp; |
299 | * @intel_dp: Intel DP |
431 | unlock: |
300 | * |
432 | mutex_unlock(&dev_priv->psr.lock); |
301 | * This function needs to be called before disabling pipe. |
433 | } |
- | 434 | ||
- | 435 | static void vlv_psr_disable(struct intel_dp *intel_dp) |
|
- | 436 | { |
|
Line 302... | Line 437... | ||
302 | */ |
437 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
- | 438 | struct drm_device *dev = intel_dig_port->base.base.dev; |
|
- | 439 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 440 | struct intel_crtc *intel_crtc = |
|
- | 441 | to_intel_crtc(intel_dig_port->base.base.crtc); |
|
- | 442 | uint32_t val; |
|
- | 443 | ||
- | 444 | if (dev_priv->psr.active) { |
|
- | 445 | /* Put VLV PSR back to PSR_state 0 that is PSR Disabled. */ |
|
303 | void intel_psr_disable(struct intel_dp *intel_dp) |
446 | if (wait_for((I915_READ(VLV_PSRSTAT(intel_crtc->pipe)) & |
- | 447 | VLV_EDP_PSR_IN_TRANS) == 0, 1)) |
|
- | 448 | WARN(1, "PSR transition took longer than expected\n"); |
|
304 | { |
449 | |
305 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
450 | val = I915_READ(VLV_PSRCTL(intel_crtc->pipe)); |
- | 451 | val &= ~VLV_EDP_PSR_ACTIVE_ENTRY; |
|
306 | struct drm_device *dev = intel_dig_port->base.base.dev; |
452 | val &= ~VLV_EDP_PSR_ENABLE; |
- | 453 | val &= ~VLV_EDP_PSR_MODE_MASK; |
|
- | 454 | I915_WRITE(VLV_PSRCTL(intel_crtc->pipe), val); |
|
- | 455 | ||
- | 456 | dev_priv->psr.active = false; |
|
- | 457 | } else { |
|
- | 458 | WARN_ON(vlv_is_psr_active_on_pipe(dev, intel_crtc->pipe)); |
|
- | 459 | } |
|
Line 307... | Line 460... | ||
307 | struct drm_i915_private *dev_priv = dev->dev_private; |
460 | } |
308 | 461 | ||
309 | mutex_lock(&dev_priv->psr.lock); |
462 | static void hsw_psr_disable(struct intel_dp *intel_dp) |
Line 323... | Line 476... | ||
323 | 476 | ||
324 | dev_priv->psr.active = false; |
477 | dev_priv->psr.active = false; |
325 | } else { |
478 | } else { |
326 | WARN_ON(I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE); |
479 | WARN_ON(I915_READ(EDP_PSR_CTL(dev)) & EDP_PSR_ENABLE); |
- | 480 | } |
|
- | 481 | } |
|
- | 482 | ||
- | 483 | /** |
|
- | 484 | * intel_psr_disable - Disable PSR |
|
- | 485 | * @intel_dp: Intel DP |
|
- | 486 | * |
|
- | 487 | * This function needs to be called before disabling pipe. |
|
- | 488 | */ |
|
- | 489 | void intel_psr_disable(struct intel_dp *intel_dp) |
|
- | 490 | { |
|
- | 491 | struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); |
|
- | 492 | struct drm_device *dev = intel_dig_port->base.base.dev; |
|
- | 493 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 494 | ||
- | 495 | mutex_lock(&dev_priv->psr.lock); |
|
- | 496 | if (!dev_priv->psr.enabled) { |
|
- | 497 | mutex_unlock(&dev_priv->psr.lock); |
|
- | 498 | return; |
|
- | 499 | } |
|
- | 500 | ||
- | 501 | if (HAS_DDI(dev)) |
|
- | 502 | hsw_psr_disable(intel_dp); |
|
- | 503 | else |
|
Line 327... | Line 504... | ||
327 | } |
504 | vlv_psr_disable(intel_dp); |
328 | 505 | ||
Line 329... | Line 506... | ||
329 | dev_priv->psr.enabled = NULL; |
506 | dev_priv->psr.enabled = NULL; |
Line 335... | Line 512... | ||
335 | static void intel_psr_work(struct work_struct *work) |
512 | static void intel_psr_work(struct work_struct *work) |
336 | { |
513 | { |
337 | struct drm_i915_private *dev_priv = |
514 | struct drm_i915_private *dev_priv = |
338 | container_of(work, typeof(*dev_priv), psr.work.work); |
515 | container_of(work, typeof(*dev_priv), psr.work.work); |
339 | struct intel_dp *intel_dp = dev_priv->psr.enabled; |
516 | struct intel_dp *intel_dp = dev_priv->psr.enabled; |
- | 517 | struct drm_crtc *crtc = dp_to_dig_port(intel_dp)->base.base.crtc; |
|
- | 518 | enum pipe pipe = to_intel_crtc(crtc)->pipe; |
|
Line 340... | Line 519... | ||
340 | 519 | ||
341 | /* We have to make sure PSR is ready for re-enable |
520 | /* We have to make sure PSR is ready for re-enable |
342 | * otherwise it keeps disabled until next full enable/disable cycle. |
521 | * otherwise it keeps disabled until next full enable/disable cycle. |
343 | * PSR might take some time to get fully disabled |
522 | * PSR might take some time to get fully disabled |
344 | * and be ready for re-enable. |
523 | * and be ready for re-enable. |
- | 524 | */ |
|
345 | */ |
525 | if (HAS_DDI(dev_priv->dev)) { |
346 | if (wait_for((I915_READ(EDP_PSR_STATUS_CTL(dev_priv->dev)) & |
526 | if (wait_for((I915_READ(EDP_PSR_STATUS_CTL(dev_priv->dev)) & |
347 | EDP_PSR_STATUS_STATE_MASK) == 0, 50)) { |
527 | EDP_PSR_STATUS_STATE_MASK) == 0, 50)) { |
348 | DRM_ERROR("Timed out waiting for PSR Idle for re-enable\n"); |
528 | DRM_ERROR("Timed out waiting for PSR Idle for re-enable\n"); |
349 | return; |
529 | return; |
- | 530 | } |
|
- | 531 | } else { |
|
- | 532 | if (wait_for((I915_READ(VLV_PSRSTAT(pipe)) & |
|
- | 533 | VLV_EDP_PSR_IN_TRANS) == 0, 1)) { |
|
- | 534 | DRM_ERROR("Timed out waiting for PSR Idle for re-enable\n"); |
|
- | 535 | return; |
|
350 | } |
536 | } |
351 | 537 | } |
|
352 | mutex_lock(&dev_priv->psr.lock); |
538 | mutex_lock(&dev_priv->psr.lock); |
Line 353... | Line 539... | ||
353 | intel_dp = dev_priv->psr.enabled; |
539 | intel_dp = dev_priv->psr.enabled; |
354 | 540 | ||
Line 361... | Line 547... | ||
361 | * won't ever miss a flush when bailing out here. |
547 | * won't ever miss a flush when bailing out here. |
362 | */ |
548 | */ |
363 | if (dev_priv->psr.busy_frontbuffer_bits) |
549 | if (dev_priv->psr.busy_frontbuffer_bits) |
364 | goto unlock; |
550 | goto unlock; |
Line 365... | Line 551... | ||
365 | 551 | ||
366 | intel_psr_do_enable(intel_dp); |
552 | intel_psr_activate(intel_dp); |
367 | unlock: |
553 | unlock: |
368 | mutex_unlock(&dev_priv->psr.lock); |
554 | mutex_unlock(&dev_priv->psr.lock); |
Line 369... | Line 555... | ||
369 | } |
555 | } |
370 | 556 | ||
371 | static void intel_psr_exit(struct drm_device *dev) |
557 | static void intel_psr_exit(struct drm_device *dev) |
- | 558 | { |
|
- | 559 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 560 | struct intel_dp *intel_dp = dev_priv->psr.enabled; |
|
- | 561 | struct drm_crtc *crtc = dp_to_dig_port(intel_dp)->base.base.crtc; |
|
Line 372... | Line 562... | ||
372 | { |
562 | enum pipe pipe = to_intel_crtc(crtc)->pipe; |
- | 563 | u32 val; |
|
- | 564 | ||
- | 565 | if (!dev_priv->psr.active) |
|
373 | struct drm_i915_private *dev_priv = dev->dev_private; |
566 | return; |
Line 374... | Line 567... | ||
374 | 567 | ||
Line 375... | Line 568... | ||
375 | if (dev_priv->psr.active) { |
568 | if (HAS_DDI(dev)) { |
- | 569 | val = I915_READ(EDP_PSR_CTL(dev)); |
|
- | 570 | ||
- | 571 | WARN_ON(!(val & EDP_PSR_ENABLE)); |
|
- | 572 | ||
- | 573 | I915_WRITE(EDP_PSR_CTL(dev), val & ~EDP_PSR_ENABLE); |
|
- | 574 | } else { |
|
- | 575 | val = I915_READ(VLV_PSRCTL(pipe)); |
|
- | 576 | ||
- | 577 | /* Here we do the transition from PSR_state 3 to PSR_state 5 |
|
- | 578 | * directly once PSR State 4 that is active with single frame |
|
- | 579 | * update can be skipped. PSR_state 5 that is PSR exit then |
|
- | 580 | * Hardware is responsible to transition back to PSR_state 1 |
|
- | 581 | * that is PSR inactive. Same state after |
|
- | 582 | * vlv_edp_psr_enable_source. |
|
- | 583 | */ |
|
- | 584 | val &= ~VLV_EDP_PSR_ACTIVE_ENTRY; |
|
- | 585 | I915_WRITE(VLV_PSRCTL(pipe), val); |
|
- | 586 | ||
- | 587 | /* Send AUX wake up - Spec says after transitioning to PSR |
|
- | 588 | * active we have to send AUX wake up by writing 01h in DPCD |
|
- | 589 | * 600h of sink device. |
|
- | 590 | * XXX: This might slow down the transition, but without this |
|
- | 591 | * HW doesn't complete the transition to PSR_state 1 and we |
|
Line 376... | Line 592... | ||
376 | u32 val = I915_READ(EDP_PSR_CTL(dev)); |
592 | * never get the screen updated. |
377 | 593 | */ |
|
Line -... | Line 594... | ||
- | 594 | drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER, |
|
- | 595 | DP_SET_POWER_D0); |
|
- | 596 | } |
|
- | 597 | ||
- | 598 | dev_priv->psr.active = false; |
|
- | 599 | } |
|
- | 600 | ||
- | 601 | /** |
|
- | 602 | * intel_psr_single_frame_update - Single Frame Update |
|
- | 603 | * @dev: DRM device |
|
- | 604 | * @frontbuffer_bits: frontbuffer plane tracking bits |
|
- | 605 | * |
|
- | 606 | * Some platforms support a single frame update feature that is used to |
|
- | 607 | * send and update only one frame on Remote Frame Buffer. |
|
- | 608 | * So far it is only implemented for Valleyview and Cherryview because |
|
- | 609 | * hardware requires this to be done before a page flip. |
|
- | 610 | */ |
|
- | 611 | void intel_psr_single_frame_update(struct drm_device *dev, |
|
- | 612 | unsigned frontbuffer_bits) |
|
- | 613 | { |
|
- | 614 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 615 | struct drm_crtc *crtc; |
|
- | 616 | enum pipe pipe; |
|
- | 617 | u32 val; |
|
- | 618 | ||
- | 619 | /* |
|
- | 620 | * Single frame update is already supported on BDW+ but it requires |
|
- | 621 | * many W/A and it isn't really needed. |
|
- | 622 | */ |
|
- | 623 | if (!IS_VALLEYVIEW(dev)) |
|
- | 624 | return; |
|
- | 625 | ||
- | 626 | mutex_lock(&dev_priv->psr.lock); |
|
- | 627 | if (!dev_priv->psr.enabled) { |
|
- | 628 | mutex_unlock(&dev_priv->psr.lock); |
|
- | 629 | return; |
|
- | 630 | } |
|
- | 631 | ||
- | 632 | crtc = dp_to_dig_port(dev_priv->psr.enabled)->base.base.crtc; |
|
- | 633 | pipe = to_intel_crtc(crtc)->pipe; |
|
- | 634 | ||
- | 635 | if (frontbuffer_bits & INTEL_FRONTBUFFER_ALL_MASK(pipe)) { |
|
- | 636 | val = I915_READ(VLV_PSRCTL(pipe)); |
|
- | 637 | ||
378 | WARN_ON(!(val & EDP_PSR_ENABLE)); |
638 | /* |
Line 379... | Line 639... | ||
379 | 639 | * We need to set this bit before writing registers for a flip. |
|
380 | I915_WRITE(EDP_PSR_CTL(dev), val & ~EDP_PSR_ENABLE); |
640 | * This bit will be self-clear when it gets to the PSR active state. |
381 | 641 | */ |
|
Line 410... | Line 670... | ||
410 | } |
670 | } |
Line 411... | Line 671... | ||
411 | 671 | ||
412 | crtc = dp_to_dig_port(dev_priv->psr.enabled)->base.base.crtc; |
672 | crtc = dp_to_dig_port(dev_priv->psr.enabled)->base.base.crtc; |
Line 413... | Line -... | ||
413 | pipe = to_intel_crtc(crtc)->pipe; |
- | |
414 | - | ||
415 | intel_psr_exit(dev); |
673 | pipe = to_intel_crtc(crtc)->pipe; |
416 | - | ||
417 | frontbuffer_bits &= INTEL_FRONTBUFFER_ALL_MASK(pipe); |
674 | |
- | 675 | frontbuffer_bits &= INTEL_FRONTBUFFER_ALL_MASK(pipe); |
|
- | 676 | dev_priv->psr.busy_frontbuffer_bits |= frontbuffer_bits; |
|
- | 677 | ||
- | 678 | if (frontbuffer_bits) |
|
418 | 679 | intel_psr_exit(dev); |
|
419 | dev_priv->psr.busy_frontbuffer_bits |= frontbuffer_bits; |
680 | |
Line 420... | Line 681... | ||
420 | mutex_unlock(&dev_priv->psr.lock); |
681 | mutex_unlock(&dev_priv->psr.lock); |
421 | } |
682 | } |
422 | 683 | ||
423 | /** |
684 | /** |
- | 685 | * intel_psr_flush - Flush PSR |
|
424 | * intel_psr_flush - Flush PSR |
686 | * @dev: DRM device |
425 | * @dev: DRM device |
687 | * @frontbuffer_bits: frontbuffer plane tracking bits |
426 | * @frontbuffer_bits: frontbuffer plane tracking bits |
688 | * @origin: which operation caused the flush |
427 | * |
689 | * |
428 | * Since the hardware frontbuffer tracking has gaps we need to integrate |
690 | * Since the hardware frontbuffer tracking has gaps we need to integrate |
429 | * with the software frontbuffer tracking. This function gets called every |
691 | * with the software frontbuffer tracking. This function gets called every |
430 | * time frontbuffer rendering has completed and flushed out to memory. PSR |
692 | * time frontbuffer rendering has completed and flushed out to memory. PSR |
431 | * can be enabled again if no other frontbuffer relevant to PSR is dirty. |
693 | * can be enabled again if no other frontbuffer relevant to PSR is dirty. |
432 | * |
694 | * |
433 | * Dirty frontbuffers relevant to PSR are tracked in busy_frontbuffer_bits. |
695 | * Dirty frontbuffers relevant to PSR are tracked in busy_frontbuffer_bits. |
434 | */ |
696 | */ |
435 | void intel_psr_flush(struct drm_device *dev, |
697 | void intel_psr_flush(struct drm_device *dev, |
436 | unsigned frontbuffer_bits) |
698 | unsigned frontbuffer_bits, enum fb_op_origin origin) |
437 | { |
699 | { |
- | 700 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
Line 438... | Line 701... | ||
438 | struct drm_i915_private *dev_priv = dev->dev_private; |
701 | struct drm_crtc *crtc; |
439 | struct drm_crtc *crtc; |
702 | enum pipe pipe; |
440 | enum pipe pipe; |
703 | int delay_ms = HAS_DDI(dev) ? 100 : 500; |
441 | 704 | ||
442 | mutex_lock(&dev_priv->psr.lock); |
705 | mutex_lock(&dev_priv->psr.lock); |
Line 443... | Line 706... | ||
443 | if (!dev_priv->psr.enabled) { |
706 | if (!dev_priv->psr.enabled) { |
444 | mutex_unlock(&dev_priv->psr.lock); |
707 | mutex_unlock(&dev_priv->psr.lock); |
- | 708 | return; |
|
- | 709 | } |
|
445 | return; |
710 | |
Line -... | Line 711... | ||
- | 711 | crtc = dp_to_dig_port(dev_priv->psr.enabled)->base.base.crtc; |
|
446 | } |
712 | pipe = to_intel_crtc(crtc)->pipe; |
447 | 713 | ||
448 | crtc = dp_to_dig_port(dev_priv->psr.enabled)->base.base.crtc; |
714 | frontbuffer_bits &= INTEL_FRONTBUFFER_ALL_MASK(pipe); |
449 | pipe = to_intel_crtc(crtc)->pipe; |
715 | dev_priv->psr.busy_frontbuffer_bits &= ~frontbuffer_bits; |
450 | dev_priv->psr.busy_frontbuffer_bits &= ~frontbuffer_bits; |
716 | |
451 | 717 | if (HAS_DDI(dev)) { |
|
452 | /* |
- | |
453 | * On Haswell sprite plane updates don't result in a psr invalidating |
718 | /* |
454 | * signal in the hardware. Which means we need to manually fake this in |
719 | * By definition every flush should mean invalidate + flush, |
- | 720 | * however on core platforms let's minimize the |
|
- | 721 | * disable/re-enable so we can avoid the invalidate when flip |
|
- | 722 | * originated the flush. |
|
- | 723 | */ |
|
- | 724 | if (frontbuffer_bits && origin != ORIGIN_FLIP) |
|
- | 725 | intel_psr_exit(dev); |
|
- | 726 | } else { |
|
- | 727 | /* |
|
- | 728 | * On Valleyview and Cherryview we don't use hardware tracking |
|
- | 729 | * so any plane updates or cursor moves don't result in a PSR |
|
Line 455... | Line 730... | ||
455 | * software for all flushes, not just when we've seen a preceding |
730 | * invalidating. Which means we need to manually fake this in |
456 | * invalidation through frontbuffer rendering. |
731 | * software for all flushes. |
457 | */ |
732 | */ |
458 | if (IS_HASWELL(dev) && |
733 | if (frontbuffer_bits) |
459 | (frontbuffer_bits & INTEL_FRONTBUFFER_SPRITE(pipe))) |
734 | intel_psr_exit(dev); |
Line 460... | Line 735... | ||
460 | intel_psr_exit(dev); |
735 | } |
461 | 736 |