1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
4 */
5
6 #include "dp_panel.h"
7
8 #include <drm/drm_connector.h>
9 #include <drm/drm_edid.h>
10 #include <drm/drm_print.h>
11
12 struct dp_panel_private {
13 struct device *dev;
14 struct drm_device *drm_dev;
15 struct dp_panel dp_panel;
16 struct drm_dp_aux *aux;
17 struct dp_link *link;
18 struct dp_catalog *catalog;
19 bool panel_on;
20 bool aux_cfg_update_done;
21 };
22
dp_panel_read_dpcd(struct dp_panel * dp_panel)23 static int dp_panel_read_dpcd(struct dp_panel *dp_panel)
24 {
25 int rc = 0;
26 size_t len;
27 ssize_t rlen;
28 struct dp_panel_private *panel;
29 struct dp_link_info *link_info;
30 u8 *dpcd, major = 0, minor = 0, temp;
31 u32 offset = DP_DPCD_REV;
32
33 dpcd = dp_panel->dpcd;
34
35 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
36 link_info = &dp_panel->link_info;
37
38 rlen = drm_dp_dpcd_read(panel->aux, offset,
39 dpcd, (DP_RECEIVER_CAP_SIZE + 1));
40 if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
41 DRM_ERROR("dpcd read failed, rlen=%zd\n", rlen);
42 if (rlen == -ETIMEDOUT)
43 rc = rlen;
44 else
45 rc = -EINVAL;
46
47 goto end;
48 }
49
50 temp = dpcd[DP_TRAINING_AUX_RD_INTERVAL];
51
52 /* check for EXTENDED_RECEIVER_CAPABILITY_FIELD_PRESENT */
53 if (temp & BIT(7)) {
54 drm_dbg_dp(panel->drm_dev,
55 "using EXTENDED_RECEIVER_CAPABILITY_FIELD\n");
56 offset = DPRX_EXTENDED_DPCD_FIELD;
57 }
58
59 rlen = drm_dp_dpcd_read(panel->aux, offset,
60 dpcd, (DP_RECEIVER_CAP_SIZE + 1));
61 if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
62 DRM_ERROR("dpcd read failed, rlen=%zd\n", rlen);
63 if (rlen == -ETIMEDOUT)
64 rc = rlen;
65 else
66 rc = -EINVAL;
67
68 goto end;
69 }
70
71 link_info->revision = dpcd[DP_DPCD_REV];
72 major = (link_info->revision >> 4) & 0x0f;
73 minor = link_info->revision & 0x0f;
74
75 link_info->rate = drm_dp_bw_code_to_link_rate(dpcd[DP_MAX_LINK_RATE]);
76 link_info->num_lanes = dpcd[DP_MAX_LANE_COUNT] & DP_MAX_LANE_COUNT_MASK;
77
78 /* Limit data lanes from data-lanes of endpoint property of dtsi */
79 if (link_info->num_lanes > dp_panel->max_dp_lanes)
80 link_info->num_lanes = dp_panel->max_dp_lanes;
81
82 /* Limit link rate from link-frequencies of endpoint property of dtsi */
83 if (link_info->rate > dp_panel->max_dp_link_rate)
84 link_info->rate = dp_panel->max_dp_link_rate;
85
86 drm_dbg_dp(panel->drm_dev, "version: %d.%d\n", major, minor);
87 drm_dbg_dp(panel->drm_dev, "link_rate=%d\n", link_info->rate);
88 drm_dbg_dp(panel->drm_dev, "lane_count=%d\n", link_info->num_lanes);
89
90 if (drm_dp_enhanced_frame_cap(dpcd))
91 link_info->capabilities |= DP_LINK_CAP_ENHANCED_FRAMING;
92
93 dp_panel->dfp_present = dpcd[DP_DOWNSTREAMPORT_PRESENT];
94 dp_panel->dfp_present &= DP_DWN_STRM_PORT_PRESENT;
95
96 if (dp_panel->dfp_present && (dpcd[DP_DPCD_REV] > 0x10)) {
97 dp_panel->ds_port_cnt = dpcd[DP_DOWN_STREAM_PORT_COUNT];
98 dp_panel->ds_port_cnt &= DP_PORT_COUNT_MASK;
99 len = DP_DOWNSTREAM_PORTS * DP_DOWNSTREAM_CAP_SIZE;
100
101 rlen = drm_dp_dpcd_read(panel->aux,
102 DP_DOWNSTREAM_PORT_0, dp_panel->ds_cap_info, len);
103 if (rlen < len) {
104 DRM_ERROR("ds port status failed, rlen=%zd\n", rlen);
105 rc = -EINVAL;
106 goto end;
107 }
108 }
109
110 end:
111 return rc;
112 }
113
dp_panel_get_supported_bpp(struct dp_panel * dp_panel,u32 mode_edid_bpp,u32 mode_pclk_khz)114 static u32 dp_panel_get_supported_bpp(struct dp_panel *dp_panel,
115 u32 mode_edid_bpp, u32 mode_pclk_khz)
116 {
117 struct dp_link_info *link_info;
118 const u32 max_supported_bpp = 30, min_supported_bpp = 18;
119 u32 bpp = 0, data_rate_khz = 0;
120
121 bpp = min_t(u32, mode_edid_bpp, max_supported_bpp);
122
123 link_info = &dp_panel->link_info;
124 data_rate_khz = link_info->num_lanes * link_info->rate * 8;
125
126 while (bpp > min_supported_bpp) {
127 if (mode_pclk_khz * bpp <= data_rate_khz)
128 break;
129 bpp -= 6;
130 }
131
132 return bpp;
133 }
134
dp_panel_update_modes(struct drm_connector * connector,struct edid * edid)135 static int dp_panel_update_modes(struct drm_connector *connector,
136 struct edid *edid)
137 {
138 int rc = 0;
139
140 if (edid) {
141 rc = drm_connector_update_edid_property(connector, edid);
142 if (rc) {
143 DRM_ERROR("failed to update edid property %d\n", rc);
144 return rc;
145 }
146 rc = drm_add_edid_modes(connector, edid);
147 return rc;
148 }
149
150 rc = drm_connector_update_edid_property(connector, NULL);
151 if (rc)
152 DRM_ERROR("failed to update edid property %d\n", rc);
153
154 return rc;
155 }
156
dp_panel_read_sink_caps(struct dp_panel * dp_panel,struct drm_connector * connector)157 int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
158 struct drm_connector *connector)
159 {
160 int rc = 0, bw_code;
161 int rlen, count;
162 struct dp_panel_private *panel;
163
164 if (!dp_panel || !connector) {
165 DRM_ERROR("invalid input\n");
166 return -EINVAL;
167 }
168
169 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
170
171 rc = dp_panel_read_dpcd(dp_panel);
172 if (rc) {
173 DRM_ERROR("read dpcd failed %d\n", rc);
174 return rc;
175 }
176
177 bw_code = drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate);
178 if (!is_link_rate_valid(bw_code) ||
179 !is_lane_count_valid(dp_panel->link_info.num_lanes) ||
180 (bw_code > dp_panel->max_bw_code)) {
181 DRM_ERROR("Illegal link rate=%d lane=%d\n", dp_panel->link_info.rate,
182 dp_panel->link_info.num_lanes);
183 return -EINVAL;
184 }
185
186 if (dp_panel->dfp_present) {
187 rlen = drm_dp_dpcd_read(panel->aux, DP_SINK_COUNT,
188 &count, 1);
189 if (rlen == 1) {
190 count = DP_GET_SINK_COUNT(count);
191 if (!count) {
192 DRM_ERROR("no downstream ports connected\n");
193 panel->link->sink_count = 0;
194 rc = -ENOTCONN;
195 goto end;
196 }
197 }
198 }
199
200 kfree(dp_panel->edid);
201 dp_panel->edid = NULL;
202
203 dp_panel->edid = drm_get_edid(connector,
204 &panel->aux->ddc);
205 if (!dp_panel->edid) {
206 DRM_ERROR("panel edid read failed\n");
207 /* check edid read fail is due to unplug */
208 if (!dp_catalog_link_is_connected(panel->catalog)) {
209 rc = -ETIMEDOUT;
210 goto end;
211 }
212 }
213
214 if (panel->aux_cfg_update_done) {
215 drm_dbg_dp(panel->drm_dev,
216 "read DPCD with updated AUX config\n");
217 rc = dp_panel_read_dpcd(dp_panel);
218 bw_code = drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate);
219 if (rc || !is_link_rate_valid(bw_code) ||
220 !is_lane_count_valid(dp_panel->link_info.num_lanes)
221 || (bw_code > dp_panel->max_bw_code)) {
222 DRM_ERROR("read dpcd failed %d\n", rc);
223 return rc;
224 }
225 panel->aux_cfg_update_done = false;
226 }
227 end:
228 return rc;
229 }
230
dp_panel_get_mode_bpp(struct dp_panel * dp_panel,u32 mode_edid_bpp,u32 mode_pclk_khz)231 u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
232 u32 mode_edid_bpp, u32 mode_pclk_khz)
233 {
234 struct dp_panel_private *panel;
235 u32 bpp;
236
237 if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
238 DRM_ERROR("invalid input\n");
239 return 0;
240 }
241
242 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
243
244 if (dp_panel->video_test)
245 bpp = dp_link_bit_depth_to_bpp(
246 panel->link->test_video.test_bit_depth);
247 else
248 bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp,
249 mode_pclk_khz);
250
251 return bpp;
252 }
253
dp_panel_get_modes(struct dp_panel * dp_panel,struct drm_connector * connector)254 int dp_panel_get_modes(struct dp_panel *dp_panel,
255 struct drm_connector *connector)
256 {
257 if (!dp_panel) {
258 DRM_ERROR("invalid input\n");
259 return -EINVAL;
260 }
261
262 if (dp_panel->edid)
263 return dp_panel_update_modes(connector, dp_panel->edid);
264
265 return 0;
266 }
267
dp_panel_get_edid_checksum(struct edid * edid)268 static u8 dp_panel_get_edid_checksum(struct edid *edid)
269 {
270 struct edid *last_block;
271 u8 *raw_edid;
272 bool is_edid_corrupt = false;
273
274 if (!edid) {
275 DRM_ERROR("invalid edid input\n");
276 return 0;
277 }
278
279 raw_edid = (u8 *)edid;
280 raw_edid += (edid->extensions * EDID_LENGTH);
281 last_block = (struct edid *)raw_edid;
282
283 /* block type extension */
284 drm_edid_block_valid(raw_edid, 1, false, &is_edid_corrupt);
285 if (!is_edid_corrupt)
286 return last_block->checksum;
287
288 DRM_ERROR("Invalid block, no checksum\n");
289 return 0;
290 }
291
dp_panel_handle_sink_request(struct dp_panel * dp_panel)292 void dp_panel_handle_sink_request(struct dp_panel *dp_panel)
293 {
294 struct dp_panel_private *panel;
295
296 if (!dp_panel) {
297 DRM_ERROR("invalid input\n");
298 return;
299 }
300
301 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
302
303 if (panel->link->sink_request & DP_TEST_LINK_EDID_READ) {
304 u8 checksum;
305
306 if (dp_panel->edid)
307 checksum = dp_panel_get_edid_checksum(dp_panel->edid);
308 else
309 checksum = dp_panel->connector->real_edid_checksum;
310
311 dp_link_send_edid_checksum(panel->link, checksum);
312 dp_link_send_test_response(panel->link);
313 }
314 }
315
dp_panel_tpg_config(struct dp_panel * dp_panel,bool enable)316 void dp_panel_tpg_config(struct dp_panel *dp_panel, bool enable)
317 {
318 struct dp_catalog *catalog;
319 struct dp_panel_private *panel;
320
321 if (!dp_panel) {
322 DRM_ERROR("invalid input\n");
323 return;
324 }
325
326 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
327 catalog = panel->catalog;
328
329 if (!panel->panel_on) {
330 drm_dbg_dp(panel->drm_dev,
331 "DP panel not enabled, handle TPG on next on\n");
332 return;
333 }
334
335 if (!enable) {
336 dp_catalog_panel_tpg_disable(catalog);
337 return;
338 }
339
340 drm_dbg_dp(panel->drm_dev, "calling catalog tpg_enable\n");
341 dp_catalog_panel_tpg_enable(catalog, &panel->dp_panel.dp_mode.drm_mode);
342 }
343
dp_panel_dump_regs(struct dp_panel * dp_panel)344 void dp_panel_dump_regs(struct dp_panel *dp_panel)
345 {
346 struct dp_catalog *catalog;
347 struct dp_panel_private *panel;
348
349 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
350 catalog = panel->catalog;
351
352 dp_catalog_dump_regs(catalog);
353 }
354
dp_panel_timing_cfg(struct dp_panel * dp_panel)355 int dp_panel_timing_cfg(struct dp_panel *dp_panel)
356 {
357 u32 data, total_ver, total_hor;
358 struct dp_catalog *catalog;
359 struct dp_panel_private *panel;
360 struct drm_display_mode *drm_mode;
361
362 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
363 catalog = panel->catalog;
364 drm_mode = &panel->dp_panel.dp_mode.drm_mode;
365
366 drm_dbg_dp(panel->drm_dev, "width=%d hporch= %d %d %d\n",
367 drm_mode->hdisplay, drm_mode->htotal - drm_mode->hsync_end,
368 drm_mode->hsync_start - drm_mode->hdisplay,
369 drm_mode->hsync_end - drm_mode->hsync_start);
370
371 drm_dbg_dp(panel->drm_dev, "height=%d vporch= %d %d %d\n",
372 drm_mode->vdisplay, drm_mode->vtotal - drm_mode->vsync_end,
373 drm_mode->vsync_start - drm_mode->vdisplay,
374 drm_mode->vsync_end - drm_mode->vsync_start);
375
376 total_hor = drm_mode->htotal;
377
378 total_ver = drm_mode->vtotal;
379
380 data = total_ver;
381 data <<= 16;
382 data |= total_hor;
383
384 catalog->total = data;
385
386 data = (drm_mode->vtotal - drm_mode->vsync_start);
387 data <<= 16;
388 data |= (drm_mode->htotal - drm_mode->hsync_start);
389
390 catalog->sync_start = data;
391
392 data = drm_mode->vsync_end - drm_mode->vsync_start;
393 data <<= 16;
394 data |= (panel->dp_panel.dp_mode.v_active_low << 31);
395 data |= drm_mode->hsync_end - drm_mode->hsync_start;
396 data |= (panel->dp_panel.dp_mode.h_active_low << 15);
397
398 catalog->width_blanking = data;
399
400 data = drm_mode->vdisplay;
401 data <<= 16;
402 data |= drm_mode->hdisplay;
403
404 catalog->dp_active = data;
405
406 dp_catalog_panel_timing_cfg(catalog);
407 panel->panel_on = true;
408
409 return 0;
410 }
411
dp_panel_init_panel_info(struct dp_panel * dp_panel)412 int dp_panel_init_panel_info(struct dp_panel *dp_panel)
413 {
414 struct drm_display_mode *drm_mode;
415 struct dp_panel_private *panel;
416
417 drm_mode = &dp_panel->dp_mode.drm_mode;
418
419 panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
420
421 /*
422 * print resolution info as this is a result
423 * of user initiated action of cable connection
424 */
425 drm_dbg_dp(panel->drm_dev, "SET NEW RESOLUTION:\n");
426 drm_dbg_dp(panel->drm_dev, "%dx%d@%dfps\n",
427 drm_mode->hdisplay, drm_mode->vdisplay, drm_mode_vrefresh(drm_mode));
428 drm_dbg_dp(panel->drm_dev,
429 "h_porches(back|front|width) = (%d|%d|%d)\n",
430 drm_mode->htotal - drm_mode->hsync_end,
431 drm_mode->hsync_start - drm_mode->hdisplay,
432 drm_mode->hsync_end - drm_mode->hsync_start);
433 drm_dbg_dp(panel->drm_dev,
434 "v_porches(back|front|width) = (%d|%d|%d)\n",
435 drm_mode->vtotal - drm_mode->vsync_end,
436 drm_mode->vsync_start - drm_mode->vdisplay,
437 drm_mode->vsync_end - drm_mode->vsync_start);
438 drm_dbg_dp(panel->drm_dev, "pixel clock (KHz)=(%d)\n",
439 drm_mode->clock);
440 drm_dbg_dp(panel->drm_dev, "bpp = %d\n", dp_panel->dp_mode.bpp);
441
442 dp_panel->dp_mode.bpp = max_t(u32, 18,
443 min_t(u32, dp_panel->dp_mode.bpp, 30));
444 drm_dbg_dp(panel->drm_dev, "updated bpp = %d\n",
445 dp_panel->dp_mode.bpp);
446
447 return 0;
448 }
449
dp_panel_get(struct dp_panel_in * in)450 struct dp_panel *dp_panel_get(struct dp_panel_in *in)
451 {
452 struct dp_panel_private *panel;
453 struct dp_panel *dp_panel;
454
455 if (!in->dev || !in->catalog || !in->aux || !in->link) {
456 DRM_ERROR("invalid input\n");
457 return ERR_PTR(-EINVAL);
458 }
459
460 panel = devm_kzalloc(in->dev, sizeof(*panel), GFP_KERNEL);
461 if (!panel)
462 return ERR_PTR(-ENOMEM);
463
464 panel->dev = in->dev;
465 panel->aux = in->aux;
466 panel->catalog = in->catalog;
467 panel->link = in->link;
468
469 dp_panel = &panel->dp_panel;
470 dp_panel->max_bw_code = DP_LINK_BW_8_1;
471 panel->aux_cfg_update_done = false;
472
473 return dp_panel;
474 }
475
dp_panel_put(struct dp_panel * dp_panel)476 void dp_panel_put(struct dp_panel *dp_panel)
477 {
478 if (!dp_panel)
479 return;
480
481 kfree(dp_panel->edid);
482 }
483