Branch data Line data Source code
1 : : /*
2 : : * Copyright © 2013 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
21 : : * DEALINGS IN THE SOFTWARE.
22 : : *
23 : : * Author: Jani Nikula <jani.nikula@intel.com>
24 : : */
25 : :
26 : : #include <linux/slab.h>
27 : :
28 : : #include <drm/drm_atomic_helper.h>
29 : : #include <drm/drm_crtc.h>
30 : : #include <drm/drm_edid.h>
31 : : #include <drm/drm_mipi_dsi.h>
32 : :
33 : : #include "i915_drv.h"
34 : : #include "intel_atomic.h"
35 : : #include "intel_connector.h"
36 : : #include "intel_display_types.h"
37 : : #include "intel_dsi.h"
38 : : #include "intel_fifo_underrun.h"
39 : : #include "intel_panel.h"
40 : : #include "intel_sideband.h"
41 : :
42 : : /* return pixels in terms of txbyteclkhs */
43 : 0 : static u16 txbyteclkhs(u16 pixels, int bpp, int lane_count,
44 : : u16 burst_mode_ratio)
45 : : {
46 : 0 : return DIV_ROUND_UP(DIV_ROUND_UP(pixels * bpp * burst_mode_ratio,
47 : : 8 * 100), lane_count);
48 : : }
49 : :
50 : : /* return pixels equvalent to txbyteclkhs */
51 : 0 : static u16 pixels_from_txbyteclkhs(u16 clk_hs, int bpp, int lane_count,
52 : : u16 burst_mode_ratio)
53 : : {
54 : 0 : return DIV_ROUND_UP((clk_hs * lane_count * 8 * 100),
55 : : (bpp * burst_mode_ratio));
56 : : }
57 : :
58 : 0 : enum mipi_dsi_pixel_format pixel_format_from_register_bits(u32 fmt)
59 : : {
60 : : /* It just so happens the VBT matches register contents. */
61 [ # # # # : 0 : switch (fmt) {
# ]
62 : : case VID_MODE_FORMAT_RGB888:
63 : : return MIPI_DSI_FMT_RGB888;
64 : 0 : case VID_MODE_FORMAT_RGB666:
65 : 0 : return MIPI_DSI_FMT_RGB666;
66 : 0 : case VID_MODE_FORMAT_RGB666_PACKED:
67 : 0 : return MIPI_DSI_FMT_RGB666_PACKED;
68 : 0 : case VID_MODE_FORMAT_RGB565:
69 : 0 : return MIPI_DSI_FMT_RGB565;
70 : : default:
71 : 0 : MISSING_CASE(fmt);
72 : 0 : return MIPI_DSI_FMT_RGB666;
73 : : }
74 : : }
75 : :
76 : 0 : void vlv_dsi_wait_for_fifo_empty(struct intel_dsi *intel_dsi, enum port port)
77 : : {
78 : 0 : struct drm_encoder *encoder = &intel_dsi->base.base;
79 : 0 : struct drm_device *dev = encoder->dev;
80 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(dev);
81 : 0 : u32 mask;
82 : :
83 : 0 : mask = LP_CTRL_FIFO_EMPTY | HS_CTRL_FIFO_EMPTY |
84 : : LP_DATA_FIFO_EMPTY | HS_DATA_FIFO_EMPTY;
85 : :
86 [ # # # # ]: 0 : if (intel_de_wait_for_set(dev_priv, MIPI_GEN_FIFO_STAT(port),
87 : : mask, 100))
88 : 0 : DRM_ERROR("DPI FIFOs are not empty\n");
89 : 0 : }
90 : :
91 : 0 : static void write_data(struct drm_i915_private *dev_priv,
92 : : i915_reg_t reg,
93 : : const u8 *data, u32 len)
94 : : {
95 : 0 : u32 i, j;
96 : :
97 [ # # ]: 0 : for (i = 0; i < len; i += 4) {
98 : : u32 val = 0;
99 : :
100 [ # # ]: 0 : for (j = 0; j < min_t(u32, len - i, 4); j++)
101 : 0 : val |= *data++ << 8 * j;
102 : :
103 : 0 : I915_WRITE(reg, val);
104 : : }
105 : 0 : }
106 : :
107 : 0 : static void read_data(struct drm_i915_private *dev_priv,
108 : : i915_reg_t reg,
109 : : u8 *data, u32 len)
110 : : {
111 : 0 : u32 i, j;
112 : :
113 [ # # ]: 0 : for (i = 0; i < len; i += 4) {
114 : 0 : u32 val = I915_READ(reg);
115 : :
116 [ # # ]: 0 : for (j = 0; j < min_t(u32, len - i, 4); j++)
117 : 0 : *data++ = val >> 8 * j;
118 : : }
119 : 0 : }
120 : :
121 : 0 : static ssize_t intel_dsi_host_transfer(struct mipi_dsi_host *host,
122 : : const struct mipi_dsi_msg *msg)
123 : : {
124 : 0 : struct intel_dsi_host *intel_dsi_host = to_intel_dsi_host(host);
125 : 0 : struct drm_device *dev = intel_dsi_host->intel_dsi->base.base.dev;
126 : 0 : struct drm_i915_private *dev_priv = to_i915(dev);
127 : 0 : enum port port = intel_dsi_host->port;
128 : 0 : struct mipi_dsi_packet packet;
129 : 0 : ssize_t ret;
130 : 0 : const u8 *header, *data;
131 : 0 : i915_reg_t data_reg, ctrl_reg;
132 : 0 : u32 data_mask, ctrl_mask;
133 : :
134 : 0 : ret = mipi_dsi_create_packet(&packet, msg);
135 [ # # ]: 0 : if (ret < 0)
136 : : return ret;
137 : :
138 : 0 : header = packet.header;
139 : 0 : data = packet.payload;
140 : :
141 [ # # ]: 0 : if (msg->flags & MIPI_DSI_MSG_USE_LPM) {
142 [ # # ]: 0 : data_reg = MIPI_LP_GEN_DATA(port);
143 : 0 : data_mask = LP_DATA_FIFO_FULL;
144 [ # # ]: 0 : ctrl_reg = MIPI_LP_GEN_CTRL(port);
145 : : ctrl_mask = LP_CTRL_FIFO_FULL;
146 : : } else {
147 [ # # ]: 0 : data_reg = MIPI_HS_GEN_DATA(port);
148 : 0 : data_mask = HS_DATA_FIFO_FULL;
149 [ # # ]: 0 : ctrl_reg = MIPI_HS_GEN_CTRL(port);
150 : : ctrl_mask = HS_CTRL_FIFO_FULL;
151 : : }
152 : :
153 : : /* note: this is never true for reads */
154 [ # # ]: 0 : if (packet.payload_length) {
155 [ # # # # ]: 0 : if (intel_de_wait_for_clear(dev_priv, MIPI_GEN_FIFO_STAT(port),
156 : : data_mask, 50))
157 : 0 : DRM_ERROR("Timeout waiting for HS/LP DATA FIFO !full\n");
158 : :
159 : 0 : write_data(dev_priv, data_reg, packet.payload,
160 : 0 : packet.payload_length);
161 : : }
162 : :
163 [ # # ]: 0 : if (msg->rx_len) {
164 [ # # ]: 0 : I915_WRITE(MIPI_INTR_STAT(port), GEN_READ_DATA_AVAIL);
165 : : }
166 : :
167 [ # # # # ]: 0 : if (intel_de_wait_for_clear(dev_priv, MIPI_GEN_FIFO_STAT(port),
168 : : ctrl_mask, 50)) {
169 : 0 : DRM_ERROR("Timeout waiting for HS/LP CTRL FIFO !full\n");
170 : : }
171 : :
172 : 0 : I915_WRITE(ctrl_reg, header[2] << 16 | header[1] << 8 | header[0]);
173 : :
174 : : /* ->rx_len is set only for reads */
175 [ # # ]: 0 : if (msg->rx_len) {
176 : 0 : data_mask = GEN_READ_DATA_AVAIL;
177 [ # # # # ]: 0 : if (intel_de_wait_for_set(dev_priv, MIPI_INTR_STAT(port),
178 : : data_mask, 50))
179 : 0 : DRM_ERROR("Timeout waiting for read data.\n");
180 : :
181 : 0 : read_data(dev_priv, data_reg, msg->rx_buf, msg->rx_len);
182 : : }
183 : :
184 : : /* XXX: fix for reads and writes */
185 : 0 : return 4 + packet.payload_length;
186 : : }
187 : :
188 : 0 : static int intel_dsi_host_attach(struct mipi_dsi_host *host,
189 : : struct mipi_dsi_device *dsi)
190 : : {
191 : 0 : return 0;
192 : : }
193 : :
194 : 0 : static int intel_dsi_host_detach(struct mipi_dsi_host *host,
195 : : struct mipi_dsi_device *dsi)
196 : : {
197 : 0 : return 0;
198 : : }
199 : :
200 : : static const struct mipi_dsi_host_ops intel_dsi_host_ops = {
201 : : .attach = intel_dsi_host_attach,
202 : : .detach = intel_dsi_host_detach,
203 : : .transfer = intel_dsi_host_transfer,
204 : : };
205 : :
206 : : /*
207 : : * send a video mode command
208 : : *
209 : : * XXX: commands with data in MIPI_DPI_DATA?
210 : : */
211 : 0 : static int dpi_send_cmd(struct intel_dsi *intel_dsi, u32 cmd, bool hs,
212 : : enum port port)
213 : : {
214 : 0 : struct drm_encoder *encoder = &intel_dsi->base.base;
215 : 0 : struct drm_device *dev = encoder->dev;
216 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(dev);
217 : 0 : u32 mask;
218 : :
219 : : /* XXX: pipe, hs */
220 [ # # ]: 0 : if (hs)
221 : 0 : cmd &= ~DPI_LP_MODE;
222 : : else
223 : 0 : cmd |= DPI_LP_MODE;
224 : :
225 : : /* clear bit */
226 [ # # ]: 0 : I915_WRITE(MIPI_INTR_STAT(port), SPL_PKT_SENT_INTERRUPT);
227 : :
228 : : /* XXX: old code skips write if control unchanged */
229 [ # # # # ]: 0 : if (cmd == I915_READ(MIPI_DPI_CONTROL(port)))
230 : 0 : DRM_DEBUG_KMS("Same special packet %02x twice in a row.\n", cmd);
231 : :
232 [ # # ]: 0 : I915_WRITE(MIPI_DPI_CONTROL(port), cmd);
233 : :
234 : 0 : mask = SPL_PKT_SENT_INTERRUPT;
235 [ # # # # ]: 0 : if (intel_de_wait_for_set(dev_priv, MIPI_INTR_STAT(port), mask, 100))
236 : 0 : DRM_ERROR("Video mode command 0x%08x send failed.\n", cmd);
237 : :
238 : 0 : return 0;
239 : : }
240 : :
241 : 0 : static void band_gap_reset(struct drm_i915_private *dev_priv)
242 : : {
243 : 0 : vlv_flisdsi_get(dev_priv);
244 : :
245 : 0 : vlv_flisdsi_write(dev_priv, 0x08, 0x0001);
246 : 0 : vlv_flisdsi_write(dev_priv, 0x0F, 0x0005);
247 : 0 : vlv_flisdsi_write(dev_priv, 0x0F, 0x0025);
248 : 0 : udelay(150);
249 : 0 : vlv_flisdsi_write(dev_priv, 0x0F, 0x0000);
250 : 0 : vlv_flisdsi_write(dev_priv, 0x08, 0x0000);
251 : :
252 : 0 : vlv_flisdsi_put(dev_priv);
253 : 0 : }
254 : :
255 : 0 : static int intel_dsi_compute_config(struct intel_encoder *encoder,
256 : : struct intel_crtc_state *pipe_config,
257 : : struct drm_connector_state *conn_state)
258 : : {
259 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
260 : 0 : struct intel_dsi *intel_dsi = container_of(encoder, struct intel_dsi,
261 : : base);
262 : 0 : struct intel_connector *intel_connector = intel_dsi->attached_connector;
263 : 0 : struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
264 : 0 : const struct drm_display_mode *fixed_mode = intel_connector->panel.fixed_mode;
265 : 0 : struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
266 : 0 : int ret;
267 : :
268 : 0 : DRM_DEBUG_KMS("\n");
269 : 0 : pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
270 : :
271 [ # # ]: 0 : if (fixed_mode) {
272 : 0 : intel_fixed_panel_mode(fixed_mode, adjusted_mode);
273 : :
274 [ # # ]: 0 : if (HAS_GMCH(dev_priv))
275 : 0 : intel_gmch_panel_fitting(crtc, pipe_config,
276 : 0 : conn_state->scaling_mode);
277 : : else
278 : 0 : intel_pch_panel_fitting(crtc, pipe_config,
279 : 0 : conn_state->scaling_mode);
280 : : }
281 : :
282 [ # # ]: 0 : if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN)
283 : : return -EINVAL;
284 : :
285 : : /* DSI uses short packets for sync events, so clear mode flags for DSI */
286 : 0 : adjusted_mode->flags = 0;
287 : :
288 [ # # ]: 0 : if (intel_dsi->pixel_format == MIPI_DSI_FMT_RGB888)
289 : 0 : pipe_config->pipe_bpp = 24;
290 : : else
291 : 0 : pipe_config->pipe_bpp = 18;
292 : :
293 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
294 : : /* Enable Frame time stamp based scanline reporting */
295 : 0 : adjusted_mode->private_flags |=
296 : : I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP;
297 : :
298 : : /* Dual link goes to DSI transcoder A. */
299 [ # # ]: 0 : if (intel_dsi->ports == BIT(PORT_C))
300 : 0 : pipe_config->cpu_transcoder = TRANSCODER_DSI_C;
301 : : else
302 : 0 : pipe_config->cpu_transcoder = TRANSCODER_DSI_A;
303 : :
304 : 0 : ret = bxt_dsi_pll_compute(encoder, pipe_config);
305 [ # # ]: 0 : if (ret)
306 : : return -EINVAL;
307 : : } else {
308 : 0 : ret = vlv_dsi_pll_compute(encoder, pipe_config);
309 [ # # ]: 0 : if (ret)
310 : : return -EINVAL;
311 : : }
312 : :
313 : 0 : pipe_config->clock_set = true;
314 : :
315 : 0 : return 0;
316 : : }
317 : :
318 : 0 : static bool glk_dsi_enable_io(struct intel_encoder *encoder)
319 : : {
320 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
321 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
322 : 0 : enum port port;
323 : 0 : u32 tmp;
324 : 0 : bool cold_boot = false;
325 : :
326 : : /* Set the MIPI mode
327 : : * If MIPI_Mode is off, then writing to LP_Wake bit is not reflecting.
328 : : * Power ON MIPI IO first and then write into IO reset and LP wake bits
329 : : */
330 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
331 [ # # ]: 0 : tmp = I915_READ(MIPI_CTRL(port));
332 [ # # ]: 0 : I915_WRITE(MIPI_CTRL(port), tmp | GLK_MIPIIO_ENABLE);
333 : : }
334 : :
335 : : /* Put the IO into reset */
336 : 0 : tmp = I915_READ(MIPI_CTRL(PORT_A));
337 : 0 : tmp &= ~GLK_MIPIIO_RESET_RELEASED;
338 : 0 : I915_WRITE(MIPI_CTRL(PORT_A), tmp);
339 : :
340 : : /* Program LP Wake */
341 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
342 [ # # ]: 0 : tmp = I915_READ(MIPI_CTRL(port));
343 [ # # # # ]: 0 : if (!(I915_READ(MIPI_DEVICE_READY(port)) & DEVICE_READY))
344 : 0 : tmp &= ~GLK_LP_WAKE;
345 : : else
346 : 0 : tmp |= GLK_LP_WAKE;
347 [ # # ]: 0 : I915_WRITE(MIPI_CTRL(port), tmp);
348 : : }
349 : :
350 : : /* Wait for Pwr ACK */
351 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
352 [ # # # # ]: 0 : if (intel_de_wait_for_set(dev_priv, MIPI_CTRL(port),
353 : : GLK_MIPIIO_PORT_POWERED, 20))
354 : 0 : DRM_ERROR("MIPIO port is powergated\n");
355 : : }
356 : :
357 : : /* Check for cold boot scenario */
358 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
359 : 0 : cold_boot |=
360 [ # # ]: 0 : !(I915_READ(MIPI_DEVICE_READY(port)) & DEVICE_READY);
361 : : }
362 : :
363 : 0 : return cold_boot;
364 : : }
365 : :
366 : 0 : static void glk_dsi_device_ready(struct intel_encoder *encoder)
367 : : {
368 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
369 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
370 : 0 : enum port port;
371 : 0 : u32 val;
372 : :
373 : : /* Wait for MIPI PHY status bit to set */
374 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
375 [ # # # # ]: 0 : if (intel_de_wait_for_set(dev_priv, MIPI_CTRL(port),
376 : : GLK_PHY_STATUS_PORT_READY, 20))
377 : 0 : DRM_ERROR("PHY is not ON\n");
378 : : }
379 : :
380 : : /* Get IO out of reset */
381 : 0 : val = I915_READ(MIPI_CTRL(PORT_A));
382 : 0 : I915_WRITE(MIPI_CTRL(PORT_A), val | GLK_MIPIIO_RESET_RELEASED);
383 : :
384 : : /* Get IO out of Low power state*/
385 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
386 [ # # # # ]: 0 : if (!(I915_READ(MIPI_DEVICE_READY(port)) & DEVICE_READY)) {
387 [ # # ]: 0 : val = I915_READ(MIPI_DEVICE_READY(port));
388 : 0 : val &= ~ULPS_STATE_MASK;
389 : 0 : val |= DEVICE_READY;
390 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), val);
391 : 0 : usleep_range(10, 15);
392 : : } else {
393 : : /* Enter ULPS */
394 [ # # ]: 0 : val = I915_READ(MIPI_DEVICE_READY(port));
395 : 0 : val &= ~ULPS_STATE_MASK;
396 : 0 : val |= (ULPS_STATE_ENTER | DEVICE_READY);
397 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), val);
398 : :
399 : : /* Wait for ULPS active */
400 [ # # # # ]: 0 : if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
401 : : GLK_ULPS_NOT_ACTIVE, 20))
402 : 0 : DRM_ERROR("ULPS not active\n");
403 : :
404 : : /* Exit ULPS */
405 [ # # ]: 0 : val = I915_READ(MIPI_DEVICE_READY(port));
406 : 0 : val &= ~ULPS_STATE_MASK;
407 : 0 : val |= (ULPS_STATE_EXIT | DEVICE_READY);
408 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), val);
409 : :
410 : : /* Enter Normal Mode */
411 [ # # ]: 0 : val = I915_READ(MIPI_DEVICE_READY(port));
412 : 0 : val &= ~ULPS_STATE_MASK;
413 : 0 : val |= (ULPS_STATE_NORMAL_OPERATION | DEVICE_READY);
414 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), val);
415 : :
416 [ # # ]: 0 : val = I915_READ(MIPI_CTRL(port));
417 : 0 : val &= ~GLK_LP_WAKE;
418 [ # # ]: 0 : I915_WRITE(MIPI_CTRL(port), val);
419 : : }
420 : : }
421 : :
422 : : /* Wait for Stop state */
423 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
424 [ # # # # ]: 0 : if (intel_de_wait_for_set(dev_priv, MIPI_CTRL(port),
425 : : GLK_DATA_LANE_STOP_STATE, 20))
426 : 0 : DRM_ERROR("Date lane not in STOP state\n");
427 : : }
428 : :
429 : : /* Wait for AFE LATCH */
430 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
431 [ # # # # ]: 0 : if (intel_de_wait_for_set(dev_priv, BXT_MIPI_PORT_CTRL(port),
432 : : AFE_LATCHOUT, 20))
433 : 0 : DRM_ERROR("D-PHY not entering LP-11 state\n");
434 : : }
435 : 0 : }
436 : :
437 : 0 : static void bxt_dsi_device_ready(struct intel_encoder *encoder)
438 : : {
439 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
440 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
441 : 0 : enum port port;
442 : 0 : u32 val;
443 : :
444 : 0 : DRM_DEBUG_KMS("\n");
445 : :
446 : : /* Enable MIPI PHY transparent latch */
447 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
448 [ # # ]: 0 : val = I915_READ(BXT_MIPI_PORT_CTRL(port));
449 : 0 : I915_WRITE(BXT_MIPI_PORT_CTRL(port), val | LP_OUTPUT_HOLD);
450 : 0 : usleep_range(2000, 2500);
451 : : }
452 : :
453 : : /* Clear ULPS and set device ready */
454 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
455 [ # # ]: 0 : val = I915_READ(MIPI_DEVICE_READY(port));
456 : 0 : val &= ~ULPS_STATE_MASK;
457 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), val);
458 : 0 : usleep_range(2000, 2500);
459 : 0 : val |= DEVICE_READY;
460 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), val);
461 : : }
462 : 0 : }
463 : :
464 : 0 : static void vlv_dsi_device_ready(struct intel_encoder *encoder)
465 : : {
466 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
467 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
468 : 0 : enum port port;
469 : 0 : u32 val;
470 : :
471 : 0 : DRM_DEBUG_KMS("\n");
472 : :
473 : 0 : vlv_flisdsi_get(dev_priv);
474 : : /* program rcomp for compliance, reduce from 50 ohms to 45 ohms
475 : : * needed everytime after power gate */
476 : 0 : vlv_flisdsi_write(dev_priv, 0x04, 0x0004);
477 : 0 : vlv_flisdsi_put(dev_priv);
478 : :
479 : : /* bandgap reset is needed after everytime we do power gate */
480 : 0 : band_gap_reset(dev_priv);
481 : :
482 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
483 : :
484 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), ULPS_STATE_ENTER);
485 : 0 : usleep_range(2500, 3000);
486 : :
487 : : /* Enable MIPI PHY transparent latch
488 : : * Common bit for both MIPI Port A & MIPI Port C
489 : : * No similar bit in MIPI Port C reg
490 : : */
491 : 0 : val = I915_READ(MIPI_PORT_CTRL(PORT_A));
492 : 0 : I915_WRITE(MIPI_PORT_CTRL(PORT_A), val | LP_OUTPUT_HOLD);
493 : 0 : usleep_range(1000, 1500);
494 : :
495 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), ULPS_STATE_EXIT);
496 : 0 : usleep_range(2500, 3000);
497 : :
498 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), DEVICE_READY);
499 : 0 : usleep_range(2500, 3000);
500 : : }
501 : 0 : }
502 : :
503 : 0 : static void intel_dsi_device_ready(struct intel_encoder *encoder)
504 : : {
505 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
506 : :
507 [ # # ]: 0 : if (IS_GEMINILAKE(dev_priv))
508 : 0 : glk_dsi_device_ready(encoder);
509 [ # # # # ]: 0 : else if (IS_GEN9_LP(dev_priv))
510 : 0 : bxt_dsi_device_ready(encoder);
511 : : else
512 : 0 : vlv_dsi_device_ready(encoder);
513 : 0 : }
514 : :
515 : 0 : static void glk_dsi_enter_low_power_mode(struct intel_encoder *encoder)
516 : : {
517 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
518 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
519 : 0 : enum port port;
520 : 0 : u32 val;
521 : :
522 : : /* Enter ULPS */
523 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
524 [ # # ]: 0 : val = I915_READ(MIPI_DEVICE_READY(port));
525 : 0 : val &= ~ULPS_STATE_MASK;
526 : 0 : val |= (ULPS_STATE_ENTER | DEVICE_READY);
527 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), val);
528 : : }
529 : :
530 : : /* Wait for MIPI PHY status bit to unset */
531 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
532 [ # # # # ]: 0 : if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
533 : : GLK_PHY_STATUS_PORT_READY, 20))
534 : 0 : DRM_ERROR("PHY is not turning OFF\n");
535 : : }
536 : :
537 : : /* Wait for Pwr ACK bit to unset */
538 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
539 [ # # # # ]: 0 : if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
540 : : GLK_MIPIIO_PORT_POWERED, 20))
541 : 0 : DRM_ERROR("MIPI IO Port is not powergated\n");
542 : : }
543 : 0 : }
544 : :
545 : 0 : static void glk_dsi_disable_mipi_io(struct intel_encoder *encoder)
546 : : {
547 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
548 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
549 : 0 : enum port port;
550 : 0 : u32 tmp;
551 : :
552 : : /* Put the IO into reset */
553 : 0 : tmp = I915_READ(MIPI_CTRL(PORT_A));
554 : 0 : tmp &= ~GLK_MIPIIO_RESET_RELEASED;
555 : 0 : I915_WRITE(MIPI_CTRL(PORT_A), tmp);
556 : :
557 : : /* Wait for MIPI PHY status bit to unset */
558 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
559 [ # # # # ]: 0 : if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
560 : : GLK_PHY_STATUS_PORT_READY, 20))
561 : 0 : DRM_ERROR("PHY is not turning OFF\n");
562 : : }
563 : :
564 : : /* Clear MIPI mode */
565 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
566 [ # # ]: 0 : tmp = I915_READ(MIPI_CTRL(port));
567 : 0 : tmp &= ~GLK_MIPIIO_ENABLE;
568 [ # # ]: 0 : I915_WRITE(MIPI_CTRL(port), tmp);
569 : : }
570 : 0 : }
571 : :
572 : 0 : static void glk_dsi_clear_device_ready(struct intel_encoder *encoder)
573 : : {
574 : 0 : glk_dsi_enter_low_power_mode(encoder);
575 : 0 : glk_dsi_disable_mipi_io(encoder);
576 : 0 : }
577 : :
578 : 0 : static void vlv_dsi_clear_device_ready(struct intel_encoder *encoder)
579 : : {
580 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
581 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
582 : 0 : enum port port;
583 : :
584 : 0 : DRM_DEBUG_KMS("\n");
585 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
586 : : /* Common bit for both MIPI Port A & MIPI Port C on VLV/CHV */
587 [ # # ]: 0 : i915_reg_t port_ctrl = IS_GEN9_LP(dev_priv) ?
588 [ # # # # ]: 0 : BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(PORT_A);
589 : 0 : u32 val;
590 : :
591 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), DEVICE_READY |
592 : : ULPS_STATE_ENTER);
593 : 0 : usleep_range(2000, 2500);
594 : :
595 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), DEVICE_READY |
596 : : ULPS_STATE_EXIT);
597 : 0 : usleep_range(2000, 2500);
598 : :
599 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), DEVICE_READY |
600 : : ULPS_STATE_ENTER);
601 : 0 : usleep_range(2000, 2500);
602 : :
603 : : /*
604 : : * On VLV/CHV, wait till Clock lanes are in LP-00 state for MIPI
605 : : * Port A only. MIPI Port C has no similar bit for checking.
606 : : */
607 [ # # # # : 0 : if ((IS_GEN9_LP(dev_priv) || port == PORT_A) &&
# # ]
608 [ # # ]: 0 : intel_de_wait_for_clear(dev_priv, port_ctrl,
609 : : AFE_LATCHOUT, 30))
610 : 0 : DRM_ERROR("DSI LP not going Low\n");
611 : :
612 : : /* Disable MIPI PHY transparent latch */
613 : 0 : val = I915_READ(port_ctrl);
614 : 0 : I915_WRITE(port_ctrl, val & ~LP_OUTPUT_HOLD);
615 : 0 : usleep_range(1000, 1500);
616 : :
617 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), 0x00);
618 : 0 : usleep_range(2000, 2500);
619 : : }
620 : 0 : }
621 : :
622 : : static void intel_dsi_port_enable(struct intel_encoder *encoder,
623 : : const struct intel_crtc_state *crtc_state)
624 : : {
625 : : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
626 : : struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
627 : : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
628 : : enum port port;
629 : :
630 : : if (intel_dsi->dual_link == DSI_DUAL_LINK_FRONT_BACK) {
631 : : u32 temp;
632 : : if (IS_GEN9_LP(dev_priv)) {
633 : : for_each_dsi_port(port, intel_dsi->ports) {
634 : : temp = I915_READ(MIPI_CTRL(port));
635 : : temp &= ~BXT_PIXEL_OVERLAP_CNT_MASK |
636 : : intel_dsi->pixel_overlap <<
637 : : BXT_PIXEL_OVERLAP_CNT_SHIFT;
638 : : I915_WRITE(MIPI_CTRL(port), temp);
639 : : }
640 : : } else {
641 : : temp = I915_READ(VLV_CHICKEN_3);
642 : : temp &= ~PIXEL_OVERLAP_CNT_MASK |
643 : : intel_dsi->pixel_overlap <<
644 : : PIXEL_OVERLAP_CNT_SHIFT;
645 : : I915_WRITE(VLV_CHICKEN_3, temp);
646 : : }
647 : : }
648 : :
649 : : for_each_dsi_port(port, intel_dsi->ports) {
650 : : i915_reg_t port_ctrl = IS_GEN9_LP(dev_priv) ?
651 : : BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(port);
652 : : u32 temp;
653 : :
654 : : temp = I915_READ(port_ctrl);
655 : :
656 : : temp &= ~LANE_CONFIGURATION_MASK;
657 : : temp &= ~DUAL_LINK_MODE_MASK;
658 : :
659 : : if (intel_dsi->ports == (BIT(PORT_A) | BIT(PORT_C))) {
660 : : temp |= (intel_dsi->dual_link - 1)
661 : : << DUAL_LINK_MODE_SHIFT;
662 : : if (IS_BROXTON(dev_priv))
663 : : temp |= LANE_CONFIGURATION_DUAL_LINK_A;
664 : : else
665 : : temp |= crtc->pipe ?
666 : : LANE_CONFIGURATION_DUAL_LINK_B :
667 : : LANE_CONFIGURATION_DUAL_LINK_A;
668 : : }
669 : :
670 : : if (intel_dsi->pixel_format != MIPI_DSI_FMT_RGB888)
671 : : temp |= DITHERING_ENABLE;
672 : :
673 : : /* assert ip_tg_enable signal */
674 : : I915_WRITE(port_ctrl, temp | DPI_ENABLE);
675 : : POSTING_READ(port_ctrl);
676 : : }
677 : : }
678 : :
679 : 0 : static void intel_dsi_port_disable(struct intel_encoder *encoder)
680 : : {
681 : 0 : struct drm_device *dev = encoder->base.dev;
682 : 0 : struct drm_i915_private *dev_priv = to_i915(dev);
683 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
684 : 0 : enum port port;
685 : :
686 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
687 [ # # ]: 0 : i915_reg_t port_ctrl = IS_GEN9_LP(dev_priv) ?
688 [ # # # # : 0 : BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(port);
# # ]
689 : 0 : u32 temp;
690 : :
691 : : /* de-assert ip_tg_enable signal */
692 : 0 : temp = I915_READ(port_ctrl);
693 : 0 : I915_WRITE(port_ctrl, temp & ~DPI_ENABLE);
694 : 0 : POSTING_READ(port_ctrl);
695 : : }
696 : 0 : }
697 : :
698 : : static void intel_dsi_prepare(struct intel_encoder *intel_encoder,
699 : : const struct intel_crtc_state *pipe_config);
700 : : static void intel_dsi_unprepare(struct intel_encoder *encoder);
701 : :
702 : : /*
703 : : * Panel enable/disable sequences from the VBT spec.
704 : : *
705 : : * Note the spec has AssertReset / DeassertReset swapped from their
706 : : * usual naming. We use the normal names to avoid confusion (so below
707 : : * they are swapped compared to the spec).
708 : : *
709 : : * Steps starting with MIPI refer to VBT sequences, note that for v2
710 : : * VBTs several steps which have a VBT in v2 are expected to be handled
711 : : * directly by the driver, by directly driving gpios for example.
712 : : *
713 : : * v2 video mode seq v3 video mode seq command mode seq
714 : : * - power on - MIPIPanelPowerOn - power on
715 : : * - wait t1+t2 - wait t1+t2
716 : : * - MIPIDeassertResetPin - MIPIDeassertResetPin - MIPIDeassertResetPin
717 : : * - io lines to lp-11 - io lines to lp-11 - io lines to lp-11
718 : : * - MIPISendInitialDcsCmds - MIPISendInitialDcsCmds - MIPISendInitialDcsCmds
719 : : * - MIPITearOn
720 : : * - MIPIDisplayOn
721 : : * - turn on DPI - turn on DPI - set pipe to dsr mode
722 : : * - MIPIDisplayOn - MIPIDisplayOn
723 : : * - wait t5 - wait t5
724 : : * - backlight on - MIPIBacklightOn - backlight on
725 : : * ... ... ... issue mem cmds ...
726 : : * - backlight off - MIPIBacklightOff - backlight off
727 : : * - wait t6 - wait t6
728 : : * - MIPIDisplayOff
729 : : * - turn off DPI - turn off DPI - disable pipe dsr mode
730 : : * - MIPITearOff
731 : : * - MIPIDisplayOff - MIPIDisplayOff
732 : : * - io lines to lp-00 - io lines to lp-00 - io lines to lp-00
733 : : * - MIPIAssertResetPin - MIPIAssertResetPin - MIPIAssertResetPin
734 : : * - wait t3 - wait t3
735 : : * - power off - MIPIPanelPowerOff - power off
736 : : * - wait t4 - wait t4
737 : : */
738 : :
739 : : /*
740 : : * DSI port enable has to be done before pipe and plane enable, so we do it in
741 : : * the pre_enable hook instead of the enable hook.
742 : : */
743 : 0 : static void intel_dsi_pre_enable(struct intel_encoder *encoder,
744 : : const struct intel_crtc_state *pipe_config,
745 : : const struct drm_connector_state *conn_state)
746 : : {
747 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
748 : 0 : struct drm_crtc *crtc = pipe_config->uapi.crtc;
749 : 0 : struct drm_i915_private *dev_priv = to_i915(crtc->dev);
750 : 0 : struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
751 : 0 : enum pipe pipe = intel_crtc->pipe;
752 : 0 : enum port port;
753 : 0 : u32 val;
754 : 0 : bool glk_cold_boot = false;
755 : :
756 : 0 : DRM_DEBUG_KMS("\n");
757 : :
758 : 0 : intel_set_cpu_fifo_underrun_reporting(dev_priv, pipe, true);
759 : :
760 : : /*
761 : : * The BIOS may leave the PLL in a wonky state where it doesn't
762 : : * lock. It needs to be fully powered down to fix it.
763 : : */
764 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
765 : 0 : bxt_dsi_pll_disable(encoder);
766 : 0 : bxt_dsi_pll_enable(encoder, pipe_config);
767 : : } else {
768 : 0 : vlv_dsi_pll_disable(encoder);
769 : 0 : vlv_dsi_pll_enable(encoder, pipe_config);
770 : : }
771 : :
772 [ # # ]: 0 : if (IS_BROXTON(dev_priv)) {
773 : : /* Add MIPI IO reset programming for modeset */
774 : 0 : val = I915_READ(BXT_P_CR_GT_DISP_PWRON);
775 : 0 : I915_WRITE(BXT_P_CR_GT_DISP_PWRON,
776 : : val | MIPIO_RST_CTRL);
777 : :
778 : : /* Power up DSI regulator */
779 : 0 : I915_WRITE(BXT_P_DSI_REGULATOR_CFG, STAP_SELECT);
780 : 0 : I915_WRITE(BXT_P_DSI_REGULATOR_TX_CTRL, 0);
781 : : }
782 : :
783 [ # # # # ]: 0 : if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
784 : 0 : u32 val;
785 : :
786 : : /* Disable DPOunit clock gating, can stall pipe */
787 : 0 : val = I915_READ(DSPCLK_GATE_D);
788 : 0 : val |= DPOUNIT_CLOCK_GATE_DISABLE;
789 : 0 : I915_WRITE(DSPCLK_GATE_D, val);
790 : : }
791 : :
792 [ # # ]: 0 : if (!IS_GEMINILAKE(dev_priv))
793 : 0 : intel_dsi_prepare(encoder, pipe_config);
794 : :
795 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_POWER_ON);
796 : 0 : intel_dsi_msleep(intel_dsi, intel_dsi->panel_on_delay);
797 : :
798 : : /* Deassert reset */
799 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DEASSERT_RESET);
800 : :
801 [ # # ]: 0 : if (IS_GEMINILAKE(dev_priv)) {
802 : 0 : glk_cold_boot = glk_dsi_enable_io(encoder);
803 : :
804 : : /* Prepare port in cold boot(s3/s4) scenario */
805 [ # # ]: 0 : if (glk_cold_boot)
806 : 0 : intel_dsi_prepare(encoder, pipe_config);
807 : : }
808 : :
809 : : /* Put device in ready state (LP-11) */
810 : 0 : intel_dsi_device_ready(encoder);
811 : :
812 : : /* Prepare port in normal boot scenario */
813 [ # # # # ]: 0 : if (IS_GEMINILAKE(dev_priv) && !glk_cold_boot)
814 : 0 : intel_dsi_prepare(encoder, pipe_config);
815 : :
816 : : /* Send initialization commands in LP mode */
817 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_INIT_OTP);
818 : :
819 : : /* Enable port in pre-enable phase itself because as per hw team
820 : : * recommendation, port should be enabled befor plane & pipe */
821 [ # # ]: 0 : if (is_cmd_mode(intel_dsi)) {
822 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports)
823 [ # # ]: 0 : I915_WRITE(MIPI_MAX_RETURN_PKT_SIZE(port), 8 * 4);
824 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_TEAR_ON);
825 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_ON);
826 : : } else {
827 : 0 : msleep(20); /* XXX */
828 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports)
829 : 0 : dpi_send_cmd(intel_dsi, TURN_ON, false, port);
830 : 0 : intel_dsi_msleep(intel_dsi, 100);
831 : :
832 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_ON);
833 : :
834 : 0 : intel_dsi_port_enable(encoder, pipe_config);
835 : : }
836 : :
837 : 0 : intel_panel_enable_backlight(pipe_config, conn_state);
838 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_BACKLIGHT_ON);
839 : 0 : }
840 : :
841 : : /*
842 : : * DSI port disable has to be done after pipe and plane disable, so we do it in
843 : : * the post_disable hook.
844 : : */
845 : 0 : static void intel_dsi_disable(struct intel_encoder *encoder,
846 : : const struct intel_crtc_state *old_crtc_state,
847 : : const struct drm_connector_state *old_conn_state)
848 : : {
849 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
850 : 0 : enum port port;
851 : :
852 : 0 : DRM_DEBUG_KMS("\n");
853 : :
854 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_BACKLIGHT_OFF);
855 : 0 : intel_panel_disable_backlight(old_conn_state);
856 : :
857 : : /*
858 : : * According to the spec we should send SHUTDOWN before
859 : : * MIPI_SEQ_DISPLAY_OFF only for v3+ VBTs, but field testing
860 : : * has shown that the v3 sequence works for v2 VBTs too
861 : : */
862 [ # # ]: 0 : if (is_vid_mode(intel_dsi)) {
863 : : /* Send Shutdown command to the panel in LP mode */
864 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports)
865 : 0 : dpi_send_cmd(intel_dsi, SHUTDOWN, false, port);
866 : 0 : msleep(10);
867 : : }
868 : 0 : }
869 : :
870 : 0 : static void intel_dsi_clear_device_ready(struct intel_encoder *encoder)
871 : : {
872 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
873 : :
874 [ # # ]: 0 : if (IS_GEMINILAKE(dev_priv))
875 : 0 : glk_dsi_clear_device_ready(encoder);
876 : : else
877 : 0 : vlv_dsi_clear_device_ready(encoder);
878 : 0 : }
879 : :
880 : 0 : static void intel_dsi_post_disable(struct intel_encoder *encoder,
881 : : const struct intel_crtc_state *old_crtc_state,
882 : : const struct drm_connector_state *old_conn_state)
883 : : {
884 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
885 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
886 : 0 : enum port port;
887 : 0 : u32 val;
888 : :
889 : 0 : DRM_DEBUG_KMS("\n");
890 : :
891 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
892 : 0 : intel_crtc_vblank_off(old_crtc_state);
893 : :
894 : 0 : skl_scaler_disable(old_crtc_state);
895 : : }
896 : :
897 [ # # ]: 0 : if (is_vid_mode(intel_dsi)) {
898 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports)
899 : 0 : vlv_dsi_wait_for_fifo_empty(intel_dsi, port);
900 : :
901 : 0 : intel_dsi_port_disable(encoder);
902 : 0 : usleep_range(2000, 5000);
903 : : }
904 : :
905 : 0 : intel_dsi_unprepare(encoder);
906 : :
907 : : /*
908 : : * if disable packets are sent before sending shutdown packet then in
909 : : * some next enable sequence send turn on packet error is observed
910 : : */
911 [ # # ]: 0 : if (is_cmd_mode(intel_dsi))
912 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_TEAR_OFF);
913 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_OFF);
914 : :
915 : : /* Transition to LP-00 */
916 : 0 : intel_dsi_clear_device_ready(encoder);
917 : :
918 [ # # ]: 0 : if (IS_BROXTON(dev_priv)) {
919 : : /* Power down DSI regulator to save power */
920 : 0 : I915_WRITE(BXT_P_DSI_REGULATOR_CFG, STAP_SELECT);
921 : 0 : I915_WRITE(BXT_P_DSI_REGULATOR_TX_CTRL, HS_IO_CTRL_SELECT);
922 : :
923 : : /* Add MIPI IO reset programming for modeset */
924 : 0 : val = I915_READ(BXT_P_CR_GT_DISP_PWRON);
925 : 0 : I915_WRITE(BXT_P_CR_GT_DISP_PWRON,
926 : : val & ~MIPIO_RST_CTRL);
927 : : }
928 : :
929 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
930 : 0 : bxt_dsi_pll_disable(encoder);
931 : : } else {
932 : 0 : u32 val;
933 : :
934 : 0 : vlv_dsi_pll_disable(encoder);
935 : :
936 : 0 : val = I915_READ(DSPCLK_GATE_D);
937 : 0 : val &= ~DPOUNIT_CLOCK_GATE_DISABLE;
938 : 0 : I915_WRITE(DSPCLK_GATE_D, val);
939 : : }
940 : :
941 : : /* Assert reset */
942 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_ASSERT_RESET);
943 : :
944 : 0 : intel_dsi_msleep(intel_dsi, intel_dsi->panel_off_delay);
945 : 0 : intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_POWER_OFF);
946 : :
947 : : /*
948 : : * FIXME As we do with eDP, just make a note of the time here
949 : : * and perform the wait before the next panel power on.
950 : : */
951 : 0 : intel_dsi_msleep(intel_dsi, intel_dsi->panel_pwr_cycle_delay);
952 : 0 : }
953 : :
954 : 0 : static bool intel_dsi_get_hw_state(struct intel_encoder *encoder,
955 : : enum pipe *pipe)
956 : : {
957 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
958 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
959 : 0 : intel_wakeref_t wakeref;
960 : 0 : enum port port;
961 : 0 : bool active = false;
962 : :
963 : 0 : DRM_DEBUG_KMS("\n");
964 : :
965 : 0 : wakeref = intel_display_power_get_if_enabled(dev_priv,
966 : : encoder->power_domain);
967 [ # # ]: 0 : if (!wakeref)
968 : : return false;
969 : :
970 : : /*
971 : : * On Broxton the PLL needs to be enabled with a valid divider
972 : : * configuration, otherwise accessing DSI registers will hang the
973 : : * machine. See BSpec North Display Engine registers/MIPI[BXT].
974 : : */
975 [ # # # # : 0 : if (IS_GEN9_LP(dev_priv) && !bxt_dsi_pll_is_enabled(dev_priv))
# # ]
976 : 0 : goto out_put_power;
977 : :
978 : : /* XXX: this only works for one DSI output */
979 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
980 [ # # ]: 0 : i915_reg_t ctrl_reg = IS_GEN9_LP(dev_priv) ?
981 [ # # # # : 0 : BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(port);
# # ]
982 : 0 : bool enabled = I915_READ(ctrl_reg) & DPI_ENABLE;
983 : :
984 : : /*
985 : : * Due to some hardware limitations on VLV/CHV, the DPI enable
986 : : * bit in port C control register does not get set. As a
987 : : * workaround, check pipe B conf instead.
988 : : */
989 [ # # # # : 0 : if ((IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) &&
# # ]
990 : : port == PORT_C)
991 : 0 : enabled = I915_READ(PIPECONF(PIPE_B)) & PIPECONF_ENABLE;
992 : :
993 : : /* Try command mode if video mode not enabled */
994 [ # # ]: 0 : if (!enabled) {
995 [ # # ]: 0 : u32 tmp = I915_READ(MIPI_DSI_FUNC_PRG(port));
996 : 0 : enabled = tmp & CMD_MODE_DATA_WIDTH_MASK;
997 : : }
998 : :
999 [ # # ]: 0 : if (!enabled)
1000 : 0 : continue;
1001 : :
1002 [ # # # # ]: 0 : if (!(I915_READ(MIPI_DEVICE_READY(port)) & DEVICE_READY))
1003 : 0 : continue;
1004 : :
1005 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
1006 [ # # ]: 0 : u32 tmp = I915_READ(MIPI_CTRL(port));
1007 : 0 : tmp &= BXT_PIPE_SELECT_MASK;
1008 : 0 : tmp >>= BXT_PIPE_SELECT_SHIFT;
1009 : :
1010 [ # # # # ]: 0 : if (WARN_ON(tmp > PIPE_C))
1011 : 0 : continue;
1012 : :
1013 : 0 : *pipe = tmp;
1014 : : } else {
1015 : 0 : *pipe = port == PORT_A ? PIPE_A : PIPE_B;
1016 : : }
1017 : :
1018 : : active = true;
1019 : : break;
1020 : : }
1021 : :
1022 : 0 : out_put_power:
1023 : 0 : intel_display_power_put(dev_priv, encoder->power_domain, wakeref);
1024 : :
1025 : 0 : return active;
1026 : : }
1027 : :
1028 : 0 : static void bxt_dsi_get_pipe_config(struct intel_encoder *encoder,
1029 : : struct intel_crtc_state *pipe_config)
1030 : : {
1031 : 0 : struct drm_device *dev = encoder->base.dev;
1032 : 0 : struct drm_i915_private *dev_priv = to_i915(dev);
1033 : 0 : struct drm_display_mode *adjusted_mode =
1034 : : &pipe_config->hw.adjusted_mode;
1035 : 0 : struct drm_display_mode *adjusted_mode_sw;
1036 : 0 : struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
1037 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
1038 : 0 : unsigned int lane_count = intel_dsi->lane_count;
1039 : 0 : unsigned int bpp, fmt;
1040 : 0 : enum port port;
1041 : 0 : u16 hactive, hfp, hsync, hbp, vfp, vsync, vbp;
1042 : 0 : u16 hfp_sw, hsync_sw, hbp_sw;
1043 : 0 : u16 crtc_htotal_sw, crtc_hsync_start_sw, crtc_hsync_end_sw,
1044 : : crtc_hblank_start_sw, crtc_hblank_end_sw;
1045 : :
1046 : : /* FIXME: hw readout should not depend on SW state */
1047 : 0 : adjusted_mode_sw = &crtc->config->hw.adjusted_mode;
1048 : :
1049 : : /*
1050 : : * Atleast one port is active as encoder->get_config called only if
1051 : : * encoder->get_hw_state() returns true.
1052 : : */
1053 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
1054 [ # # # # ]: 0 : if (I915_READ(BXT_MIPI_PORT_CTRL(port)) & DPI_ENABLE)
1055 : : break;
1056 : : }
1057 : :
1058 [ # # ]: 0 : fmt = I915_READ(MIPI_DSI_FUNC_PRG(port)) & VID_MODE_FORMAT_MASK;
1059 : 0 : bpp = mipi_dsi_pixel_format_to_bpp(
1060 : : pixel_format_from_register_bits(fmt));
1061 : :
1062 : 0 : pipe_config->pipe_bpp = bdw_get_pipemisc_bpp(crtc);
1063 : :
1064 : : /* Enable Frame time stamo based scanline reporting */
1065 : 0 : adjusted_mode->private_flags |=
1066 : : I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP;
1067 : :
1068 : : /* In terms of pixels */
1069 : 0 : adjusted_mode->crtc_hdisplay =
1070 [ # # ]: 0 : I915_READ(BXT_MIPI_TRANS_HACTIVE(port));
1071 : 0 : adjusted_mode->crtc_vdisplay =
1072 [ # # ]: 0 : I915_READ(BXT_MIPI_TRANS_VACTIVE(port));
1073 : 0 : adjusted_mode->crtc_vtotal =
1074 [ # # ]: 0 : I915_READ(BXT_MIPI_TRANS_VTOTAL(port));
1075 : :
1076 : 0 : hactive = adjusted_mode->crtc_hdisplay;
1077 [ # # ]: 0 : hfp = I915_READ(MIPI_HFP_COUNT(port));
1078 : :
1079 : : /*
1080 : : * Meaningful for video mode non-burst sync pulse mode only,
1081 : : * can be zero for non-burst sync events and burst modes
1082 : : */
1083 [ # # ]: 0 : hsync = I915_READ(MIPI_HSYNC_PADDING_COUNT(port));
1084 [ # # ]: 0 : hbp = I915_READ(MIPI_HBP_COUNT(port));
1085 : :
1086 : : /* harizontal values are in terms of high speed byte clock */
1087 : 0 : hfp = pixels_from_txbyteclkhs(hfp, bpp, lane_count,
1088 : 0 : intel_dsi->burst_mode_ratio);
1089 : 0 : hsync = pixels_from_txbyteclkhs(hsync, bpp, lane_count,
1090 : : intel_dsi->burst_mode_ratio);
1091 : 0 : hbp = pixels_from_txbyteclkhs(hbp, bpp, lane_count,
1092 : : intel_dsi->burst_mode_ratio);
1093 : :
1094 [ # # ]: 0 : if (intel_dsi->dual_link) {
1095 : 0 : hfp *= 2;
1096 : 0 : hsync *= 2;
1097 : 0 : hbp *= 2;
1098 : : }
1099 : :
1100 : : /* vertical values are in terms of lines */
1101 [ # # ]: 0 : vfp = I915_READ(MIPI_VFP_COUNT(port));
1102 [ # # ]: 0 : vsync = I915_READ(MIPI_VSYNC_PADDING_COUNT(port));
1103 [ # # ]: 0 : vbp = I915_READ(MIPI_VBP_COUNT(port));
1104 : :
1105 : 0 : adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp;
1106 : 0 : adjusted_mode->crtc_hsync_start = hfp + adjusted_mode->crtc_hdisplay;
1107 : 0 : adjusted_mode->crtc_hsync_end = hsync + adjusted_mode->crtc_hsync_start;
1108 : 0 : adjusted_mode->crtc_hblank_start = adjusted_mode->crtc_hdisplay;
1109 : 0 : adjusted_mode->crtc_hblank_end = adjusted_mode->crtc_htotal;
1110 : :
1111 : 0 : adjusted_mode->crtc_vsync_start = vfp + adjusted_mode->crtc_vdisplay;
1112 : 0 : adjusted_mode->crtc_vsync_end = vsync + adjusted_mode->crtc_vsync_start;
1113 : 0 : adjusted_mode->crtc_vblank_start = adjusted_mode->crtc_vdisplay;
1114 : 0 : adjusted_mode->crtc_vblank_end = adjusted_mode->crtc_vtotal;
1115 : :
1116 : : /*
1117 : : * In BXT DSI there is no regs programmed with few horizontal timings
1118 : : * in Pixels but txbyteclkhs.. So retrieval process adds some
1119 : : * ROUND_UP ERRORS in the process of PIXELS<==>txbyteclkhs.
1120 : : * Actually here for the given adjusted_mode, we are calculating the
1121 : : * value programmed to the port and then back to the horizontal timing
1122 : : * param in pixels. This is the expected value, including roundup errors
1123 : : * And if that is same as retrieved value from port, then
1124 : : * (HW state) adjusted_mode's horizontal timings are corrected to
1125 : : * match with SW state to nullify the errors.
1126 : : */
1127 : : /* Calculating the value programmed to the Port register */
1128 : 0 : hfp_sw = adjusted_mode_sw->crtc_hsync_start -
1129 : 0 : adjusted_mode_sw->crtc_hdisplay;
1130 : 0 : hsync_sw = adjusted_mode_sw->crtc_hsync_end -
1131 : : adjusted_mode_sw->crtc_hsync_start;
1132 : 0 : hbp_sw = adjusted_mode_sw->crtc_htotal -
1133 : : adjusted_mode_sw->crtc_hsync_end;
1134 : :
1135 [ # # ]: 0 : if (intel_dsi->dual_link) {
1136 : 0 : hfp_sw /= 2;
1137 : 0 : hsync_sw /= 2;
1138 : 0 : hbp_sw /= 2;
1139 : : }
1140 : :
1141 : 0 : hfp_sw = txbyteclkhs(hfp_sw, bpp, lane_count,
1142 : 0 : intel_dsi->burst_mode_ratio);
1143 : 0 : hsync_sw = txbyteclkhs(hsync_sw, bpp, lane_count,
1144 : : intel_dsi->burst_mode_ratio);
1145 : 0 : hbp_sw = txbyteclkhs(hbp_sw, bpp, lane_count,
1146 : : intel_dsi->burst_mode_ratio);
1147 : :
1148 : : /* Reverse calculating the adjusted mode parameters from port reg vals*/
1149 : 0 : hfp_sw = pixels_from_txbyteclkhs(hfp_sw, bpp, lane_count,
1150 : : intel_dsi->burst_mode_ratio);
1151 : 0 : hsync_sw = pixels_from_txbyteclkhs(hsync_sw, bpp, lane_count,
1152 : : intel_dsi->burst_mode_ratio);
1153 : 0 : hbp_sw = pixels_from_txbyteclkhs(hbp_sw, bpp, lane_count,
1154 : : intel_dsi->burst_mode_ratio);
1155 : :
1156 [ # # ]: 0 : if (intel_dsi->dual_link) {
1157 : 0 : hfp_sw *= 2;
1158 : 0 : hsync_sw *= 2;
1159 : 0 : hbp_sw *= 2;
1160 : : }
1161 : :
1162 : 0 : crtc_htotal_sw = adjusted_mode_sw->crtc_hdisplay + hfp_sw +
1163 : 0 : hsync_sw + hbp_sw;
1164 : 0 : crtc_hsync_start_sw = hfp_sw + adjusted_mode_sw->crtc_hdisplay;
1165 : 0 : crtc_hsync_end_sw = hsync_sw + crtc_hsync_start_sw;
1166 : 0 : crtc_hblank_start_sw = adjusted_mode_sw->crtc_hdisplay;
1167 : 0 : crtc_hblank_end_sw = crtc_htotal_sw;
1168 : :
1169 [ # # ]: 0 : if (adjusted_mode->crtc_htotal == crtc_htotal_sw)
1170 : 0 : adjusted_mode->crtc_htotal = adjusted_mode_sw->crtc_htotal;
1171 : :
1172 [ # # ]: 0 : if (adjusted_mode->crtc_hsync_start == crtc_hsync_start_sw)
1173 : 0 : adjusted_mode->crtc_hsync_start =
1174 : 0 : adjusted_mode_sw->crtc_hsync_start;
1175 : :
1176 [ # # ]: 0 : if (adjusted_mode->crtc_hsync_end == crtc_hsync_end_sw)
1177 : 0 : adjusted_mode->crtc_hsync_end =
1178 : 0 : adjusted_mode_sw->crtc_hsync_end;
1179 : :
1180 [ # # ]: 0 : if (adjusted_mode->crtc_hblank_start == crtc_hblank_start_sw)
1181 : 0 : adjusted_mode->crtc_hblank_start =
1182 : 0 : adjusted_mode_sw->crtc_hblank_start;
1183 : :
1184 [ # # ]: 0 : if (adjusted_mode->crtc_hblank_end == crtc_hblank_end_sw)
1185 : 0 : adjusted_mode->crtc_hblank_end =
1186 : 0 : adjusted_mode_sw->crtc_hblank_end;
1187 : 0 : }
1188 : :
1189 : 0 : static void intel_dsi_get_config(struct intel_encoder *encoder,
1190 : : struct intel_crtc_state *pipe_config)
1191 : : {
1192 : 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1193 : 0 : u32 pclk;
1194 : 0 : DRM_DEBUG_KMS("\n");
1195 : :
1196 : 0 : pipe_config->output_types |= BIT(INTEL_OUTPUT_DSI);
1197 : :
1198 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
1199 : 0 : bxt_dsi_get_pipe_config(encoder, pipe_config);
1200 : 0 : pclk = bxt_dsi_get_pclk(encoder, pipe_config);
1201 : : } else {
1202 : 0 : pclk = vlv_dsi_get_pclk(encoder, pipe_config);
1203 : : }
1204 : :
1205 [ # # ]: 0 : if (pclk) {
1206 : 0 : pipe_config->hw.adjusted_mode.crtc_clock = pclk;
1207 : 0 : pipe_config->port_clock = pclk;
1208 : : }
1209 : 0 : }
1210 : :
1211 : : /* return txclkesc cycles in terms of divider and duration in us */
1212 : 0 : static u16 txclkesc(u32 divider, unsigned int us)
1213 : : {
1214 : 0 : switch (divider) {
1215 : : case ESCAPE_CLOCK_DIVIDER_1:
1216 : : default:
1217 : : return 20 * us;
1218 : 0 : case ESCAPE_CLOCK_DIVIDER_2:
1219 : 0 : return 10 * us;
1220 : 0 : case ESCAPE_CLOCK_DIVIDER_4:
1221 : 0 : return 5 * us;
1222 : : }
1223 : : }
1224 : :
1225 : 0 : static void set_dsi_timings(struct drm_encoder *encoder,
1226 : : const struct drm_display_mode *adjusted_mode)
1227 : : {
1228 : 0 : struct drm_device *dev = encoder->dev;
1229 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(dev);
1230 [ # # ]: 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(to_intel_encoder(encoder));
1231 : 0 : enum port port;
1232 [ # # ]: 0 : unsigned int bpp = mipi_dsi_pixel_format_to_bpp(intel_dsi->pixel_format);
1233 : 0 : unsigned int lane_count = intel_dsi->lane_count;
1234 : :
1235 : 0 : u16 hactive, hfp, hsync, hbp, vfp, vsync, vbp;
1236 : :
1237 : 0 : hactive = adjusted_mode->crtc_hdisplay;
1238 : 0 : hfp = adjusted_mode->crtc_hsync_start - adjusted_mode->crtc_hdisplay;
1239 : 0 : hsync = adjusted_mode->crtc_hsync_end - adjusted_mode->crtc_hsync_start;
1240 : 0 : hbp = adjusted_mode->crtc_htotal - adjusted_mode->crtc_hsync_end;
1241 : :
1242 [ # # ]: 0 : if (intel_dsi->dual_link) {
1243 : 0 : hactive /= 2;
1244 [ # # ]: 0 : if (intel_dsi->dual_link == DSI_DUAL_LINK_FRONT_BACK)
1245 : 0 : hactive += intel_dsi->pixel_overlap;
1246 : 0 : hfp /= 2;
1247 : 0 : hsync /= 2;
1248 : 0 : hbp /= 2;
1249 : : }
1250 : :
1251 : 0 : vfp = adjusted_mode->crtc_vsync_start - adjusted_mode->crtc_vdisplay;
1252 : 0 : vsync = adjusted_mode->crtc_vsync_end - adjusted_mode->crtc_vsync_start;
1253 : 0 : vbp = adjusted_mode->crtc_vtotal - adjusted_mode->crtc_vsync_end;
1254 : :
1255 : : /* horizontal values are in terms of high speed byte clock */
1256 : 0 : hactive = txbyteclkhs(hactive, bpp, lane_count,
1257 : 0 : intel_dsi->burst_mode_ratio);
1258 : 0 : hfp = txbyteclkhs(hfp, bpp, lane_count, intel_dsi->burst_mode_ratio);
1259 : 0 : hsync = txbyteclkhs(hsync, bpp, lane_count,
1260 : : intel_dsi->burst_mode_ratio);
1261 : 0 : hbp = txbyteclkhs(hbp, bpp, lane_count, intel_dsi->burst_mode_ratio);
1262 : :
1263 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
1264 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
1265 : : /*
1266 : : * Program hdisplay and vdisplay on MIPI transcoder.
1267 : : * This is different from calculated hactive and
1268 : : * vactive, as they are calculated per channel basis,
1269 : : * whereas these values should be based on resolution.
1270 : : */
1271 [ # # ]: 0 : I915_WRITE(BXT_MIPI_TRANS_HACTIVE(port),
1272 : : adjusted_mode->crtc_hdisplay);
1273 [ # # ]: 0 : I915_WRITE(BXT_MIPI_TRANS_VACTIVE(port),
1274 : : adjusted_mode->crtc_vdisplay);
1275 [ # # ]: 0 : I915_WRITE(BXT_MIPI_TRANS_VTOTAL(port),
1276 : : adjusted_mode->crtc_vtotal);
1277 : : }
1278 : :
1279 [ # # ]: 0 : I915_WRITE(MIPI_HACTIVE_AREA_COUNT(port), hactive);
1280 [ # # ]: 0 : I915_WRITE(MIPI_HFP_COUNT(port), hfp);
1281 : :
1282 : : /* meaningful for video mode non-burst sync pulse mode only,
1283 : : * can be zero for non-burst sync events and burst modes */
1284 [ # # ]: 0 : I915_WRITE(MIPI_HSYNC_PADDING_COUNT(port), hsync);
1285 [ # # ]: 0 : I915_WRITE(MIPI_HBP_COUNT(port), hbp);
1286 : :
1287 : : /* vertical values are in terms of lines */
1288 [ # # ]: 0 : I915_WRITE(MIPI_VFP_COUNT(port), vfp);
1289 [ # # ]: 0 : I915_WRITE(MIPI_VSYNC_PADDING_COUNT(port), vsync);
1290 [ # # ]: 0 : I915_WRITE(MIPI_VBP_COUNT(port), vbp);
1291 : : }
1292 : 0 : }
1293 : :
1294 : 0 : static u32 pixel_format_to_reg(enum mipi_dsi_pixel_format fmt)
1295 : : {
1296 [ # # ]: 0 : switch (fmt) {
1297 : : case MIPI_DSI_FMT_RGB888:
1298 : : return VID_MODE_FORMAT_RGB888;
1299 : : case MIPI_DSI_FMT_RGB666:
1300 : : return VID_MODE_FORMAT_RGB666;
1301 : : case MIPI_DSI_FMT_RGB666_PACKED:
1302 : : return VID_MODE_FORMAT_RGB666_PACKED;
1303 : : case MIPI_DSI_FMT_RGB565:
1304 : : return VID_MODE_FORMAT_RGB565;
1305 : : default:
1306 : 0 : MISSING_CASE(fmt);
1307 : 0 : return VID_MODE_FORMAT_RGB666;
1308 : : }
1309 : : }
1310 : :
1311 : 0 : static void intel_dsi_prepare(struct intel_encoder *intel_encoder,
1312 : : const struct intel_crtc_state *pipe_config)
1313 : : {
1314 : 0 : struct drm_encoder *encoder = &intel_encoder->base;
1315 : 0 : struct drm_device *dev = encoder->dev;
1316 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(dev);
1317 : 0 : struct intel_crtc *intel_crtc = to_intel_crtc(pipe_config->uapi.crtc);
1318 [ # # ]: 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(to_intel_encoder(encoder));
1319 : 0 : const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
1320 : 0 : enum port port;
1321 [ # # ]: 0 : unsigned int bpp = mipi_dsi_pixel_format_to_bpp(intel_dsi->pixel_format);
1322 : 0 : u32 val, tmp;
1323 : 0 : u16 mode_hdisplay;
1324 : :
1325 : 0 : DRM_DEBUG_KMS("pipe %c\n", pipe_name(intel_crtc->pipe));
1326 : :
1327 : 0 : mode_hdisplay = adjusted_mode->crtc_hdisplay;
1328 : :
1329 [ # # ]: 0 : if (intel_dsi->dual_link) {
1330 : 0 : mode_hdisplay /= 2;
1331 [ # # ]: 0 : if (intel_dsi->dual_link == DSI_DUAL_LINK_FRONT_BACK)
1332 : 0 : mode_hdisplay += intel_dsi->pixel_overlap;
1333 : : }
1334 : :
1335 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
1336 [ # # # # ]: 0 : if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
1337 : : /*
1338 : : * escape clock divider, 20MHz, shared for A and C.
1339 : : * device ready must be off when doing this! txclkesc?
1340 : : */
1341 : 0 : tmp = I915_READ(MIPI_CTRL(PORT_A));
1342 : 0 : tmp &= ~ESCAPE_CLOCK_DIVIDER_MASK;
1343 : 0 : I915_WRITE(MIPI_CTRL(PORT_A), tmp |
1344 : : ESCAPE_CLOCK_DIVIDER_1);
1345 : :
1346 : : /* read request priority is per pipe */
1347 [ # # ]: 0 : tmp = I915_READ(MIPI_CTRL(port));
1348 : 0 : tmp &= ~READ_REQUEST_PRIORITY_MASK;
1349 [ # # ]: 0 : I915_WRITE(MIPI_CTRL(port), tmp |
1350 : : READ_REQUEST_PRIORITY_HIGH);
1351 [ # # # # ]: 0 : } else if (IS_GEN9_LP(dev_priv)) {
1352 : 0 : enum pipe pipe = intel_crtc->pipe;
1353 : :
1354 [ # # ]: 0 : tmp = I915_READ(MIPI_CTRL(port));
1355 : 0 : tmp &= ~BXT_PIPE_SELECT_MASK;
1356 : :
1357 : 0 : tmp |= BXT_PIPE_SELECT(pipe);
1358 [ # # ]: 0 : I915_WRITE(MIPI_CTRL(port), tmp);
1359 : : }
1360 : :
1361 : : /* XXX: why here, why like this? handling in irq handler?! */
1362 [ # # ]: 0 : I915_WRITE(MIPI_INTR_STAT(port), 0xffffffff);
1363 [ # # ]: 0 : I915_WRITE(MIPI_INTR_EN(port), 0xffffffff);
1364 : :
1365 [ # # ]: 0 : I915_WRITE(MIPI_DPHY_PARAM(port), intel_dsi->dphy_reg);
1366 : :
1367 [ # # ]: 0 : I915_WRITE(MIPI_DPI_RESOLUTION(port),
1368 : : adjusted_mode->crtc_vdisplay << VERTICAL_ADDRESS_SHIFT |
1369 : : mode_hdisplay << HORIZONTAL_ADDRESS_SHIFT);
1370 : : }
1371 : :
1372 : 0 : set_dsi_timings(encoder, adjusted_mode);
1373 : :
1374 : 0 : val = intel_dsi->lane_count << DATA_LANES_PRG_REG_SHIFT;
1375 [ # # ]: 0 : if (is_cmd_mode(intel_dsi)) {
1376 : 0 : val |= intel_dsi->channel << CMD_MODE_CHANNEL_NUMBER_SHIFT;
1377 : 0 : val |= CMD_MODE_DATA_WIDTH_8_BIT; /* XXX */
1378 : : } else {
1379 : 0 : val |= intel_dsi->channel << VID_MODE_CHANNEL_NUMBER_SHIFT;
1380 : 0 : val |= pixel_format_to_reg(intel_dsi->pixel_format);
1381 : : }
1382 : :
1383 : 0 : tmp = 0;
1384 [ # # ]: 0 : if (intel_dsi->eotp_pkt == 0)
1385 : 0 : tmp |= EOT_DISABLE;
1386 [ # # ]: 0 : if (intel_dsi->clock_stop)
1387 : 0 : tmp |= CLOCKSTOP;
1388 : :
1389 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
1390 : 0 : tmp |= BXT_DPHY_DEFEATURE_EN;
1391 [ # # ]: 0 : if (!is_cmd_mode(intel_dsi))
1392 : 0 : tmp |= BXT_DEFEATURE_DPI_FIFO_CTR;
1393 : : }
1394 : :
1395 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
1396 [ # # ]: 0 : I915_WRITE(MIPI_DSI_FUNC_PRG(port), val);
1397 : :
1398 : : /* timeouts for recovery. one frame IIUC. if counter expires,
1399 : : * EOT and stop state. */
1400 : :
1401 : : /*
1402 : : * In burst mode, value greater than one DPI line Time in byte
1403 : : * clock (txbyteclkhs) To timeout this timer 1+ of the above
1404 : : * said value is recommended.
1405 : : *
1406 : : * In non-burst mode, Value greater than one DPI frame time in
1407 : : * byte clock(txbyteclkhs) To timeout this timer 1+ of the above
1408 : : * said value is recommended.
1409 : : *
1410 : : * In DBI only mode, value greater than one DBI frame time in
1411 : : * byte clock(txbyteclkhs) To timeout this timer 1+ of the above
1412 : : * said value is recommended.
1413 : : */
1414 : :
1415 [ # # ]: 0 : if (is_vid_mode(intel_dsi) &&
1416 [ # # ]: 0 : intel_dsi->video_mode_format == VIDEO_MODE_BURST) {
1417 [ # # ]: 0 : I915_WRITE(MIPI_HS_TX_TIMEOUT(port),
1418 : : txbyteclkhs(adjusted_mode->crtc_htotal, bpp,
1419 : : intel_dsi->lane_count,
1420 : : intel_dsi->burst_mode_ratio) + 1);
1421 : : } else {
1422 [ # # ]: 0 : I915_WRITE(MIPI_HS_TX_TIMEOUT(port),
1423 : : txbyteclkhs(adjusted_mode->crtc_vtotal *
1424 : : adjusted_mode->crtc_htotal,
1425 : : bpp, intel_dsi->lane_count,
1426 : : intel_dsi->burst_mode_ratio) + 1);
1427 : : }
1428 [ # # ]: 0 : I915_WRITE(MIPI_LP_RX_TIMEOUT(port), intel_dsi->lp_rx_timeout);
1429 [ # # ]: 0 : I915_WRITE(MIPI_TURN_AROUND_TIMEOUT(port),
1430 : : intel_dsi->turn_arnd_val);
1431 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_RESET_TIMER(port),
1432 : : intel_dsi->rst_timer_val);
1433 : :
1434 : : /* dphy stuff */
1435 : :
1436 : : /* in terms of low power clock */
1437 [ # # # # : 0 : I915_WRITE(MIPI_INIT_COUNT(port),
# ]
1438 : : txclkesc(intel_dsi->escape_clk_div, 100));
1439 : :
1440 [ # # # # : 0 : if (IS_GEN9_LP(dev_priv) && (!intel_dsi->dual_link)) {
# # ]
1441 : : /*
1442 : : * BXT spec says write MIPI_INIT_COUNT for
1443 : : * both the ports, even if only one is
1444 : : * getting used. So write the other port
1445 : : * if not in dual link mode.
1446 : : */
1447 [ # # ]: 0 : I915_WRITE(MIPI_INIT_COUNT(port ==
1448 : : PORT_A ? PORT_C : PORT_A),
1449 : : intel_dsi->init_count);
1450 : : }
1451 : :
1452 : : /* recovery disables */
1453 [ # # ]: 0 : I915_WRITE(MIPI_EOT_DISABLE(port), tmp);
1454 : :
1455 : : /* in terms of low power clock */
1456 [ # # ]: 0 : I915_WRITE(MIPI_INIT_COUNT(port), intel_dsi->init_count);
1457 : :
1458 : : /* in terms of txbyteclkhs. actual high to low switch +
1459 : : * MIPI_STOP_STATE_STALL * MIPI_LP_BYTECLK.
1460 : : *
1461 : : * XXX: write MIPI_STOP_STATE_STALL?
1462 : : */
1463 [ # # ]: 0 : I915_WRITE(MIPI_HIGH_LOW_SWITCH_COUNT(port),
1464 : : intel_dsi->hs_to_lp_count);
1465 : :
1466 : : /* XXX: low power clock equivalence in terms of byte clock.
1467 : : * the number of byte clocks occupied in one low power clock.
1468 : : * based on txbyteclkhs and txclkesc.
1469 : : * txclkesc time / txbyteclk time * (105 + MIPI_STOP_STATE_STALL
1470 : : * ) / 105.???
1471 : : */
1472 [ # # ]: 0 : I915_WRITE(MIPI_LP_BYTECLK(port), intel_dsi->lp_byte_clk);
1473 : :
1474 [ # # ]: 0 : if (IS_GEMINILAKE(dev_priv)) {
1475 [ # # ]: 0 : I915_WRITE(MIPI_TLPX_TIME_COUNT(port),
1476 : : intel_dsi->lp_byte_clk);
1477 : : /* Shadow of DPHY reg */
1478 [ # # ]: 0 : I915_WRITE(MIPI_CLK_LANE_TIMING(port),
1479 : : intel_dsi->dphy_reg);
1480 : : }
1481 : :
1482 : : /* the bw essential for transmitting 16 long packets containing
1483 : : * 252 bytes meant for dcs write memory command is programmed in
1484 : : * this register in terms of byte clocks. based on dsi transfer
1485 : : * rate and the number of lanes configured the time taken to
1486 : : * transmit 16 long packets in a dsi stream varies. */
1487 [ # # ]: 0 : I915_WRITE(MIPI_DBI_BW_CTRL(port), intel_dsi->bw_timer);
1488 : :
1489 [ # # ]: 0 : I915_WRITE(MIPI_CLK_LANE_SWITCH_TIME_CNT(port),
1490 : : intel_dsi->clk_lp_to_hs_count << LP_HS_SSW_CNT_SHIFT |
1491 : : intel_dsi->clk_hs_to_lp_count << HS_LP_PWR_SW_CNT_SHIFT);
1492 : :
1493 [ # # ]: 0 : if (is_vid_mode(intel_dsi))
1494 : : /* Some panels might have resolution which is not a
1495 : : * multiple of 64 like 1366 x 768. Enable RANDOM
1496 : : * resolution support for such panels by default */
1497 [ # # ]: 0 : I915_WRITE(MIPI_VIDEO_MODE_FORMAT(port),
1498 : : intel_dsi->video_frmt_cfg_bits |
1499 : : intel_dsi->video_mode_format |
1500 : : IP_TG_CONFIG |
1501 : : RANDOM_DPI_DISPLAY_RESOLUTION);
1502 : : }
1503 : 0 : }
1504 : :
1505 : 0 : static void intel_dsi_unprepare(struct intel_encoder *encoder)
1506 : : {
1507 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1508 [ # # ]: 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
1509 : 0 : enum port port;
1510 : 0 : u32 val;
1511 : :
1512 [ # # ]: 0 : if (IS_GEMINILAKE(dev_priv))
1513 : : return;
1514 : :
1515 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
1516 : : /* Panel commands can be sent when clock is in LP11 */
1517 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), 0x0);
1518 : :
1519 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv))
1520 : 0 : bxt_dsi_reset_clocks(encoder, port);
1521 : : else
1522 : 0 : vlv_dsi_reset_clocks(encoder, port);
1523 [ # # ]: 0 : I915_WRITE(MIPI_EOT_DISABLE(port), CLOCKSTOP);
1524 : :
1525 [ # # ]: 0 : val = I915_READ(MIPI_DSI_FUNC_PRG(port));
1526 : 0 : val &= ~VID_MODE_FORMAT_MASK;
1527 [ # # ]: 0 : I915_WRITE(MIPI_DSI_FUNC_PRG(port), val);
1528 : :
1529 [ # # ]: 0 : I915_WRITE(MIPI_DEVICE_READY(port), 0x1);
1530 : : }
1531 : : }
1532 : :
1533 : 0 : static void intel_dsi_encoder_destroy(struct drm_encoder *encoder)
1534 : : {
1535 : 0 : struct intel_dsi *intel_dsi = enc_to_intel_dsi(to_intel_encoder(encoder));
1536 : :
1537 : 0 : intel_dsi_vbt_gpio_cleanup(intel_dsi);
1538 : 0 : intel_encoder_destroy(encoder);
1539 : 0 : }
1540 : :
1541 : : static const struct drm_encoder_funcs intel_dsi_funcs = {
1542 : : .destroy = intel_dsi_encoder_destroy,
1543 : : };
1544 : :
1545 : : static const struct drm_connector_helper_funcs intel_dsi_connector_helper_funcs = {
1546 : : .get_modes = intel_dsi_get_modes,
1547 : : .mode_valid = intel_dsi_mode_valid,
1548 : : .atomic_check = intel_digital_connector_atomic_check,
1549 : : };
1550 : :
1551 : : static const struct drm_connector_funcs intel_dsi_connector_funcs = {
1552 : : .late_register = intel_connector_register,
1553 : : .early_unregister = intel_connector_unregister,
1554 : : .destroy = intel_connector_destroy,
1555 : : .fill_modes = drm_helper_probe_single_connector_modes,
1556 : : .atomic_get_property = intel_digital_connector_atomic_get_property,
1557 : : .atomic_set_property = intel_digital_connector_atomic_set_property,
1558 : : .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1559 : : .atomic_duplicate_state = intel_digital_connector_duplicate_state,
1560 : : };
1561 : :
1562 : : static enum drm_panel_orientation
1563 : : vlv_dsi_get_hw_panel_orientation(struct intel_connector *connector)
1564 : : {
1565 : : struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1566 : : struct intel_encoder *encoder = connector->encoder;
1567 : : enum intel_display_power_domain power_domain;
1568 : : enum drm_panel_orientation orientation;
1569 : : struct intel_plane *plane;
1570 : : struct intel_crtc *crtc;
1571 : : intel_wakeref_t wakeref;
1572 : : enum pipe pipe;
1573 : : u32 val;
1574 : :
1575 : : if (!encoder->get_hw_state(encoder, &pipe))
1576 : : return DRM_MODE_PANEL_ORIENTATION_UNKNOWN;
1577 : :
1578 : : crtc = intel_get_crtc_for_pipe(dev_priv, pipe);
1579 : : plane = to_intel_plane(crtc->base.primary);
1580 : :
1581 : : power_domain = POWER_DOMAIN_PIPE(pipe);
1582 : : wakeref = intel_display_power_get_if_enabled(dev_priv, power_domain);
1583 : : if (!wakeref)
1584 : : return DRM_MODE_PANEL_ORIENTATION_UNKNOWN;
1585 : :
1586 : : val = I915_READ(DSPCNTR(plane->i9xx_plane));
1587 : :
1588 : : if (!(val & DISPLAY_PLANE_ENABLE))
1589 : : orientation = DRM_MODE_PANEL_ORIENTATION_UNKNOWN;
1590 : : else if (val & DISPPLANE_ROTATE_180)
1591 : : orientation = DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP;
1592 : : else
1593 : : orientation = DRM_MODE_PANEL_ORIENTATION_NORMAL;
1594 : :
1595 : : intel_display_power_put(dev_priv, power_domain, wakeref);
1596 : :
1597 : : return orientation;
1598 : : }
1599 : :
1600 : : static enum drm_panel_orientation
1601 : 0 : vlv_dsi_get_panel_orientation(struct intel_connector *connector)
1602 : : {
1603 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1604 : 0 : enum drm_panel_orientation orientation;
1605 : :
1606 [ # # # # ]: 0 : if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
1607 : 0 : orientation = vlv_dsi_get_hw_panel_orientation(connector);
1608 [ # # ]: 0 : if (orientation != DRM_MODE_PANEL_ORIENTATION_UNKNOWN)
1609 : : return orientation;
1610 : : }
1611 : :
1612 : 0 : return intel_dsi_get_panel_orientation(connector);
1613 : : }
1614 : :
1615 : 0 : static void vlv_dsi_add_properties(struct intel_connector *connector)
1616 : : {
1617 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1618 : :
1619 [ # # ]: 0 : if (connector->panel.fixed_mode) {
1620 : 0 : u32 allowed_scalers;
1621 : :
1622 : 0 : allowed_scalers = BIT(DRM_MODE_SCALE_ASPECT) | BIT(DRM_MODE_SCALE_FULLSCREEN);
1623 [ # # ]: 0 : if (!HAS_GMCH(dev_priv))
1624 : 0 : allowed_scalers |= BIT(DRM_MODE_SCALE_CENTER);
1625 : :
1626 : 0 : drm_connector_attach_scaling_mode_property(&connector->base,
1627 : : allowed_scalers);
1628 : :
1629 : 0 : connector->base.state->scaling_mode = DRM_MODE_SCALE_ASPECT;
1630 : :
1631 : 0 : connector->base.display_info.panel_orientation =
1632 : 0 : vlv_dsi_get_panel_orientation(connector);
1633 : 0 : drm_connector_init_panel_orientation_property(
1634 : : &connector->base,
1635 : : connector->panel.fixed_mode->hdisplay,
1636 : 0 : connector->panel.fixed_mode->vdisplay);
1637 : : }
1638 : 0 : }
1639 : :
1640 : : #define NS_KHZ_RATIO 1000000
1641 : :
1642 : : #define PREPARE_CNT_MAX 0x3F
1643 : : #define EXIT_ZERO_CNT_MAX 0x3F
1644 : : #define CLK_ZERO_CNT_MAX 0xFF
1645 : : #define TRAIL_CNT_MAX 0x1F
1646 : :
1647 : 0 : static void vlv_dphy_param_init(struct intel_dsi *intel_dsi)
1648 : : {
1649 : 0 : struct drm_device *dev = intel_dsi->base.base.dev;
1650 : 0 : struct drm_i915_private *dev_priv = to_i915(dev);
1651 : 0 : struct mipi_config *mipi_config = dev_priv->vbt.dsi.config;
1652 : 0 : u32 tlpx_ns, extra_byte_count, tlpx_ui;
1653 : 0 : u32 ui_num, ui_den;
1654 : 0 : u32 prepare_cnt, exit_zero_cnt, clk_zero_cnt, trail_cnt;
1655 : 0 : u32 ths_prepare_ns, tclk_trail_ns;
1656 : 0 : u32 tclk_prepare_clkzero, ths_prepare_hszero;
1657 : 0 : u32 lp_to_hs_switch, hs_to_lp_switch;
1658 : 0 : u32 mul;
1659 : :
1660 : 0 : tlpx_ns = intel_dsi_tlpx_ns(intel_dsi);
1661 : :
1662 [ # # # ]: 0 : switch (intel_dsi->lane_count) {
1663 : : case 1:
1664 : : case 2:
1665 : : extra_byte_count = 2;
1666 : : break;
1667 : 0 : case 3:
1668 : 0 : extra_byte_count = 4;
1669 : 0 : break;
1670 : 0 : case 4:
1671 : : default:
1672 : 0 : extra_byte_count = 3;
1673 : 0 : break;
1674 : : }
1675 : :
1676 : : /* in Kbps */
1677 : 0 : ui_num = NS_KHZ_RATIO;
1678 : 0 : ui_den = intel_dsi_bitrate(intel_dsi);
1679 : :
1680 : 0 : tclk_prepare_clkzero = mipi_config->tclk_prepare_clkzero;
1681 : 0 : ths_prepare_hszero = mipi_config->ths_prepare_hszero;
1682 : :
1683 : : /*
1684 : : * B060
1685 : : * LP byte clock = TLPX/ (8UI)
1686 : : */
1687 : 0 : intel_dsi->lp_byte_clk = DIV_ROUND_UP(tlpx_ns * ui_den, 8 * ui_num);
1688 : :
1689 : : /* DDR clock period = 2 * UI
1690 : : * UI(sec) = 1/(bitrate * 10^3) (bitrate is in KHZ)
1691 : : * UI(nsec) = 10^6 / bitrate
1692 : : * DDR clock period (nsec) = 2 * UI = (2 * 10^6)/ bitrate
1693 : : * DDR clock count = ns_value / DDR clock period
1694 : : *
1695 : : * For GEMINILAKE dphy_param_reg will be programmed in terms of
1696 : : * HS byte clock count for other platform in HS ddr clock count
1697 : : */
1698 [ # # ]: 0 : mul = IS_GEMINILAKE(dev_priv) ? 8 : 2;
1699 : 0 : ths_prepare_ns = max(mipi_config->ths_prepare,
1700 : : mipi_config->tclk_prepare);
1701 : :
1702 : : /* prepare count */
1703 : 0 : prepare_cnt = DIV_ROUND_UP(ths_prepare_ns * ui_den, ui_num * mul);
1704 : :
1705 [ # # ]: 0 : if (prepare_cnt > PREPARE_CNT_MAX) {
1706 : 0 : DRM_DEBUG_KMS("prepare count too high %u\n", prepare_cnt);
1707 : 0 : prepare_cnt = PREPARE_CNT_MAX;
1708 : : }
1709 : :
1710 : : /* exit zero count */
1711 : 0 : exit_zero_cnt = DIV_ROUND_UP(
1712 : : (ths_prepare_hszero - ths_prepare_ns) * ui_den,
1713 : : ui_num * mul
1714 : : );
1715 : :
1716 : : /*
1717 : : * Exit zero is unified val ths_zero and ths_exit
1718 : : * minimum value for ths_exit = 110ns
1719 : : * min (exit_zero_cnt * 2) = 110/UI
1720 : : * exit_zero_cnt = 55/UI
1721 : : */
1722 [ # # # # ]: 0 : if (exit_zero_cnt < (55 * ui_den / ui_num) && (55 * ui_den) % ui_num)
1723 : 0 : exit_zero_cnt += 1;
1724 : :
1725 [ # # ]: 0 : if (exit_zero_cnt > EXIT_ZERO_CNT_MAX) {
1726 : 0 : DRM_DEBUG_KMS("exit zero count too high %u\n", exit_zero_cnt);
1727 : 0 : exit_zero_cnt = EXIT_ZERO_CNT_MAX;
1728 : : }
1729 : :
1730 : : /* clk zero count */
1731 : 0 : clk_zero_cnt = DIV_ROUND_UP(
1732 : : (tclk_prepare_clkzero - ths_prepare_ns)
1733 : : * ui_den, ui_num * mul);
1734 : :
1735 [ # # ]: 0 : if (clk_zero_cnt > CLK_ZERO_CNT_MAX) {
1736 : 0 : DRM_DEBUG_KMS("clock zero count too high %u\n", clk_zero_cnt);
1737 : 0 : clk_zero_cnt = CLK_ZERO_CNT_MAX;
1738 : : }
1739 : :
1740 : : /* trail count */
1741 : 0 : tclk_trail_ns = max(mipi_config->tclk_trail, mipi_config->ths_trail);
1742 : 0 : trail_cnt = DIV_ROUND_UP(tclk_trail_ns * ui_den, ui_num * mul);
1743 : :
1744 [ # # ]: 0 : if (trail_cnt > TRAIL_CNT_MAX) {
1745 : 0 : DRM_DEBUG_KMS("trail count too high %u\n", trail_cnt);
1746 : 0 : trail_cnt = TRAIL_CNT_MAX;
1747 : : }
1748 : :
1749 : : /* B080 */
1750 : 0 : intel_dsi->dphy_reg = exit_zero_cnt << 24 | trail_cnt << 16 |
1751 : 0 : clk_zero_cnt << 8 | prepare_cnt;
1752 : :
1753 : : /*
1754 : : * LP to HS switch count = 4TLPX + PREP_COUNT * mul + EXIT_ZERO_COUNT *
1755 : : * mul + 10UI + Extra Byte Count
1756 : : *
1757 : : * HS to LP switch count = THS-TRAIL + 2TLPX + Extra Byte Count
1758 : : * Extra Byte Count is calculated according to number of lanes.
1759 : : * High Low Switch Count is the Max of LP to HS and
1760 : : * HS to LP switch count
1761 : : *
1762 : : */
1763 : 0 : tlpx_ui = DIV_ROUND_UP(tlpx_ns * ui_den, ui_num);
1764 : :
1765 : : /* B044 */
1766 : : /* FIXME:
1767 : : * The comment above does not match with the code */
1768 : 0 : lp_to_hs_switch = DIV_ROUND_UP(4 * tlpx_ui + prepare_cnt * mul +
1769 : : exit_zero_cnt * mul + 10, 8);
1770 : :
1771 : 0 : hs_to_lp_switch = DIV_ROUND_UP(mipi_config->ths_trail + 2 * tlpx_ui, 8);
1772 : :
1773 : 0 : intel_dsi->hs_to_lp_count = max(lp_to_hs_switch, hs_to_lp_switch);
1774 : 0 : intel_dsi->hs_to_lp_count += extra_byte_count;
1775 : :
1776 : : /* B088 */
1777 : : /* LP -> HS for clock lanes
1778 : : * LP clk sync + LP11 + LP01 + tclk_prepare + tclk_zero +
1779 : : * extra byte count
1780 : : * 2TPLX + 1TLPX + 1 TPLX(in ns) + prepare_cnt * 2 + clk_zero_cnt *
1781 : : * 2(in UI) + extra byte count
1782 : : * In byteclks = (4TLPX + prepare_cnt * 2 + clk_zero_cnt *2 (in UI)) /
1783 : : * 8 + extra byte count
1784 : : */
1785 : 0 : intel_dsi->clk_lp_to_hs_count =
1786 : 0 : DIV_ROUND_UP(
1787 : : 4 * tlpx_ui + prepare_cnt * 2 +
1788 : : clk_zero_cnt * 2,
1789 : : 8);
1790 : :
1791 : 0 : intel_dsi->clk_lp_to_hs_count += extra_byte_count;
1792 : :
1793 : : /* HS->LP for Clock Lanes
1794 : : * Low Power clock synchronisations + 1Tx byteclk + tclk_trail +
1795 : : * Extra byte count
1796 : : * 2TLPX + 8UI + (trail_count*2)(in UI) + Extra byte count
1797 : : * In byteclks = (2*TLpx(in UI) + trail_count*2 +8)(in UI)/8 +
1798 : : * Extra byte count
1799 : : */
1800 : 0 : intel_dsi->clk_hs_to_lp_count =
1801 : 0 : DIV_ROUND_UP(2 * tlpx_ui + trail_cnt * 2 + 8,
1802 : : 8);
1803 : 0 : intel_dsi->clk_hs_to_lp_count += extra_byte_count;
1804 : :
1805 : 0 : intel_dsi_log_params(intel_dsi);
1806 : 0 : }
1807 : :
1808 : 0 : void vlv_dsi_init(struct drm_i915_private *dev_priv)
1809 : : {
1810 : 0 : struct drm_device *dev = &dev_priv->drm;
1811 : 0 : struct intel_dsi *intel_dsi;
1812 : 0 : struct intel_encoder *intel_encoder;
1813 : 0 : struct drm_encoder *encoder;
1814 : 0 : struct intel_connector *intel_connector;
1815 : 0 : struct drm_connector *connector;
1816 : 0 : struct drm_display_mode *current_mode, *fixed_mode;
1817 : 0 : enum port port;
1818 : 0 : enum pipe pipe;
1819 : :
1820 : 0 : DRM_DEBUG_KMS("\n");
1821 : :
1822 : : /* There is no detection method for MIPI so rely on VBT */
1823 [ # # ]: 0 : if (!intel_bios_is_dsi_present(dev_priv, &port))
1824 : 0 : return;
1825 : :
1826 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv))
1827 : 0 : dev_priv->mipi_mmio_base = BXT_MIPI_BASE;
1828 : : else
1829 : 0 : dev_priv->mipi_mmio_base = VLV_MIPI_BASE;
1830 : :
1831 : 0 : intel_dsi = kzalloc(sizeof(*intel_dsi), GFP_KERNEL);
1832 [ # # ]: 0 : if (!intel_dsi)
1833 : : return;
1834 : :
1835 : 0 : intel_connector = intel_connector_alloc();
1836 [ # # ]: 0 : if (!intel_connector) {
1837 : 0 : kfree(intel_dsi);
1838 : 0 : return;
1839 : : }
1840 : :
1841 : 0 : intel_encoder = &intel_dsi->base;
1842 : 0 : encoder = &intel_encoder->base;
1843 : 0 : intel_dsi->attached_connector = intel_connector;
1844 : :
1845 : 0 : connector = &intel_connector->base;
1846 : :
1847 : 0 : drm_encoder_init(dev, encoder, &intel_dsi_funcs, DRM_MODE_ENCODER_DSI,
1848 : : "DSI %c", port_name(port));
1849 : :
1850 : 0 : intel_encoder->compute_config = intel_dsi_compute_config;
1851 : 0 : intel_encoder->pre_enable = intel_dsi_pre_enable;
1852 : 0 : intel_encoder->disable = intel_dsi_disable;
1853 : 0 : intel_encoder->post_disable = intel_dsi_post_disable;
1854 : 0 : intel_encoder->get_hw_state = intel_dsi_get_hw_state;
1855 : 0 : intel_encoder->get_config = intel_dsi_get_config;
1856 : 0 : intel_encoder->update_pipe = intel_panel_update_backlight;
1857 : :
1858 : 0 : intel_connector->get_hw_state = intel_connector_get_hw_state;
1859 : :
1860 : 0 : intel_encoder->port = port;
1861 : 0 : intel_encoder->type = INTEL_OUTPUT_DSI;
1862 : 0 : intel_encoder->power_domain = POWER_DOMAIN_PORT_DSI;
1863 : 0 : intel_encoder->cloneable = 0;
1864 : :
1865 : : /*
1866 : : * On BYT/CHV, pipe A maps to MIPI DSI port A, pipe B maps to MIPI DSI
1867 : : * port C. BXT isn't limited like this.
1868 : : */
1869 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv))
1870 : 0 : intel_encoder->pipe_mask = ~0;
1871 [ # # ]: 0 : else if (port == PORT_A)
1872 : 0 : intel_encoder->pipe_mask = BIT(PIPE_A);
1873 : : else
1874 : 0 : intel_encoder->pipe_mask = BIT(PIPE_B);
1875 : :
1876 [ # # ]: 0 : if (dev_priv->vbt.dsi.config->dual_link)
1877 : 0 : intel_dsi->ports = BIT(PORT_A) | BIT(PORT_C);
1878 : : else
1879 : 0 : intel_dsi->ports = BIT(port);
1880 : :
1881 : 0 : intel_dsi->dcs_backlight_ports = dev_priv->vbt.dsi.bl_ports;
1882 : 0 : intel_dsi->dcs_cabc_ports = dev_priv->vbt.dsi.cabc_ports;
1883 : :
1884 : : /* Create a DSI host (and a device) for each port. */
1885 [ # # # # ]: 0 : for_each_dsi_port(port, intel_dsi->ports) {
1886 : 0 : struct intel_dsi_host *host;
1887 : :
1888 : 0 : host = intel_dsi_host_init(intel_dsi, &intel_dsi_host_ops,
1889 : : port);
1890 [ # # ]: 0 : if (!host)
1891 : 0 : goto err;
1892 : :
1893 : 0 : intel_dsi->dsi_hosts[port] = host;
1894 : : }
1895 : :
1896 [ # # ]: 0 : if (!intel_dsi_vbt_init(intel_dsi, MIPI_DSI_GENERIC_PANEL_ID)) {
1897 : 0 : DRM_DEBUG_KMS("no device found\n");
1898 : 0 : goto err;
1899 : : }
1900 : :
1901 : : /* Use clock read-back from current hw-state for fastboot */
1902 : 0 : current_mode = intel_encoder_current_mode(intel_encoder);
1903 [ # # ]: 0 : if (current_mode) {
1904 : 0 : DRM_DEBUG_KMS("Calculated pclk %d GOP %d\n",
1905 : : intel_dsi->pclk, current_mode->clock);
1906 [ # # ]: 0 : if (intel_fuzzy_clock_check(intel_dsi->pclk,
1907 : : current_mode->clock)) {
1908 : 0 : DRM_DEBUG_KMS("Using GOP pclk\n");
1909 : 0 : intel_dsi->pclk = current_mode->clock;
1910 : : }
1911 : :
1912 : 0 : kfree(current_mode);
1913 : : }
1914 : :
1915 : 0 : vlv_dphy_param_init(intel_dsi);
1916 : :
1917 : 0 : intel_dsi_vbt_gpio_init(intel_dsi,
1918 : 0 : intel_dsi_get_hw_state(intel_encoder, &pipe));
1919 : :
1920 : 0 : drm_connector_init(dev, connector, &intel_dsi_connector_funcs,
1921 : : DRM_MODE_CONNECTOR_DSI);
1922 : :
1923 : 0 : drm_connector_helper_add(connector, &intel_dsi_connector_helper_funcs);
1924 : :
1925 : 0 : connector->display_info.subpixel_order = SubPixelHorizontalRGB; /*XXX*/
1926 : 0 : connector->interlace_allowed = false;
1927 : 0 : connector->doublescan_allowed = false;
1928 : :
1929 : 0 : intel_connector_attach_encoder(intel_connector, intel_encoder);
1930 : :
1931 : 0 : mutex_lock(&dev->mode_config.mutex);
1932 : 0 : fixed_mode = intel_panel_vbt_fixed_mode(intel_connector);
1933 : 0 : mutex_unlock(&dev->mode_config.mutex);
1934 : :
1935 [ # # ]: 0 : if (!fixed_mode) {
1936 : 0 : DRM_DEBUG_KMS("no fixed mode\n");
1937 : 0 : goto err_cleanup_connector;
1938 : : }
1939 : :
1940 : 0 : intel_panel_init(&intel_connector->panel, fixed_mode, NULL);
1941 : 0 : intel_panel_setup_backlight(connector, INVALID_PIPE);
1942 : :
1943 : 0 : vlv_dsi_add_properties(intel_connector);
1944 : :
1945 : 0 : return;
1946 : :
1947 : : err_cleanup_connector:
1948 : 0 : drm_connector_cleanup(&intel_connector->base);
1949 : 0 : err:
1950 : 0 : drm_encoder_cleanup(&intel_encoder->base);
1951 : 0 : kfree(intel_dsi);
1952 : 0 : kfree(intel_connector);
1953 : : }
|
