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