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