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 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 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 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 return rc; 145 } 146 147 rc = drm_connector_update_edid_property(connector, NULL); 148 if (rc) 149 DRM_ERROR("failed to update edid property %d\n", rc); 150 151 return rc; 152 } 153 154 int dp_panel_read_sink_caps(struct dp_panel *dp_panel, 155 struct drm_connector *connector) 156 { 157 int rc = 0, bw_code; 158 int rlen, count; 159 struct dp_panel_private *panel; 160 161 if (!dp_panel || !connector) { 162 DRM_ERROR("invalid input\n"); 163 return -EINVAL; 164 } 165 166 panel = container_of(dp_panel, struct dp_panel_private, dp_panel); 167 168 rc = dp_panel_read_dpcd(dp_panel); 169 if (rc) { 170 DRM_ERROR("read dpcd failed %d\n", rc); 171 return rc; 172 } 173 174 bw_code = drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate); 175 if (!is_link_rate_valid(bw_code) || 176 !is_lane_count_valid(dp_panel->link_info.num_lanes) || 177 (bw_code > dp_panel->max_bw_code)) { 178 DRM_ERROR("Illegal link rate=%d lane=%d\n", dp_panel->link_info.rate, 179 dp_panel->link_info.num_lanes); 180 return -EINVAL; 181 } 182 183 if (dp_panel->dfp_present) { 184 rlen = drm_dp_dpcd_read(panel->aux, DP_SINK_COUNT, 185 &count, 1); 186 if (rlen == 1) { 187 count = DP_GET_SINK_COUNT(count); 188 if (!count) { 189 DRM_ERROR("no downstream ports connected\n"); 190 panel->link->sink_count = 0; 191 rc = -ENOTCONN; 192 goto end; 193 } 194 } 195 } 196 197 kfree(dp_panel->edid); 198 dp_panel->edid = NULL; 199 200 dp_panel->edid = drm_get_edid(connector, 201 &panel->aux->ddc); 202 if (!dp_panel->edid) { 203 DRM_ERROR("panel edid read failed\n"); 204 /* check edid read fail is due to unplug */ 205 if (!dp_catalog_link_is_connected(panel->catalog)) { 206 rc = -ETIMEDOUT; 207 goto end; 208 } 209 210 /* fail safe edid */ 211 mutex_lock(&connector->dev->mode_config.mutex); 212 if (drm_add_modes_noedid(connector, 640, 480)) 213 drm_set_preferred_mode(connector, 640, 480); 214 mutex_unlock(&connector->dev->mode_config.mutex); 215 } else { 216 /* always add fail-safe mode as backup mode */ 217 mutex_lock(&connector->dev->mode_config.mutex); 218 drm_add_modes_noedid(connector, 640, 480); 219 mutex_unlock(&connector->dev->mode_config.mutex); 220 } 221 222 if (panel->aux_cfg_update_done) { 223 DRM_DEBUG_DP("read DPCD with updated AUX config\n"); 224 rc = dp_panel_read_dpcd(dp_panel); 225 bw_code = drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate); 226 if (rc || !is_link_rate_valid(bw_code) || 227 !is_lane_count_valid(dp_panel->link_info.num_lanes) 228 || (bw_code > dp_panel->max_bw_code)) { 229 DRM_ERROR("read dpcd failed %d\n", rc); 230 return rc; 231 } 232 panel->aux_cfg_update_done = false; 233 } 234 end: 235 return rc; 236 } 237 238 u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel, 239 u32 mode_edid_bpp, u32 mode_pclk_khz) 240 { 241 struct dp_panel_private *panel; 242 u32 bpp; 243 244 if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) { 245 DRM_ERROR("invalid input\n"); 246 return 0; 247 } 248 249 panel = container_of(dp_panel, struct dp_panel_private, dp_panel); 250 251 if (dp_panel->video_test) 252 bpp = dp_link_bit_depth_to_bpp( 253 panel->link->test_video.test_bit_depth); 254 else 255 bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp, 256 mode_pclk_khz); 257 258 return bpp; 259 } 260 261 int dp_panel_get_modes(struct dp_panel *dp_panel, 262 struct drm_connector *connector, struct dp_display_mode *mode) 263 { 264 if (!dp_panel) { 265 DRM_ERROR("invalid input\n"); 266 return -EINVAL; 267 } 268 269 if (dp_panel->edid) 270 return dp_panel_update_modes(connector, dp_panel->edid); 271 272 return 0; 273 } 274 275 static u8 dp_panel_get_edid_checksum(struct edid *edid) 276 { 277 struct edid *last_block; 278 u8 *raw_edid; 279 bool is_edid_corrupt = false; 280 281 if (!edid) { 282 DRM_ERROR("invalid edid input\n"); 283 return 0; 284 } 285 286 raw_edid = (u8 *)edid; 287 raw_edid += (edid->extensions * EDID_LENGTH); 288 last_block = (struct edid *)raw_edid; 289 290 /* block type extension */ 291 drm_edid_block_valid(raw_edid, 1, false, &is_edid_corrupt); 292 if (!is_edid_corrupt) 293 return last_block->checksum; 294 295 DRM_ERROR("Invalid block, no checksum\n"); 296 return 0; 297 } 298 299 void dp_panel_handle_sink_request(struct dp_panel *dp_panel) 300 { 301 struct dp_panel_private *panel; 302 303 if (!dp_panel) { 304 DRM_ERROR("invalid input\n"); 305 return; 306 } 307 308 panel = container_of(dp_panel, struct dp_panel_private, dp_panel); 309 310 if (panel->link->sink_request & DP_TEST_LINK_EDID_READ) { 311 u8 checksum; 312 313 if (dp_panel->edid) 314 checksum = dp_panel_get_edid_checksum(dp_panel->edid); 315 else 316 checksum = dp_panel->connector->real_edid_checksum; 317 318 dp_link_send_edid_checksum(panel->link, checksum); 319 dp_link_send_test_response(panel->link); 320 } 321 } 322 323 void dp_panel_tpg_config(struct dp_panel *dp_panel, bool enable) 324 { 325 struct dp_catalog *catalog; 326 struct dp_panel_private *panel; 327 328 if (!dp_panel) { 329 DRM_ERROR("invalid input\n"); 330 return; 331 } 332 333 panel = container_of(dp_panel, struct dp_panel_private, dp_panel); 334 catalog = panel->catalog; 335 336 if (!panel->panel_on) { 337 DRM_DEBUG_DP("DP panel not enabled, handle TPG on next on\n"); 338 return; 339 } 340 341 if (!enable) { 342 dp_catalog_panel_tpg_disable(catalog); 343 return; 344 } 345 346 DRM_DEBUG_DP("%s: calling catalog tpg_enable\n", __func__); 347 dp_catalog_panel_tpg_enable(catalog, &panel->dp_panel.dp_mode.drm_mode); 348 } 349 350 void dp_panel_dump_regs(struct dp_panel *dp_panel) 351 { 352 struct dp_catalog *catalog; 353 struct dp_panel_private *panel; 354 355 panel = container_of(dp_panel, struct dp_panel_private, dp_panel); 356 catalog = panel->catalog; 357 358 dp_catalog_dump_regs(catalog); 359 } 360 361 int dp_panel_timing_cfg(struct dp_panel *dp_panel) 362 { 363 u32 data, total_ver, total_hor; 364 struct dp_catalog *catalog; 365 struct dp_panel_private *panel; 366 struct drm_display_mode *drm_mode; 367 368 panel = container_of(dp_panel, struct dp_panel_private, dp_panel); 369 catalog = panel->catalog; 370 drm_mode = &panel->dp_panel.dp_mode.drm_mode; 371 372 DRM_DEBUG_DP("width=%d hporch= %d %d %d\n", 373 drm_mode->hdisplay, drm_mode->htotal - drm_mode->hsync_end, 374 drm_mode->hsync_start - drm_mode->hdisplay, 375 drm_mode->hsync_end - drm_mode->hsync_start); 376 377 DRM_DEBUG_DP("height=%d vporch= %d %d %d\n", 378 drm_mode->vdisplay, drm_mode->vtotal - drm_mode->vsync_end, 379 drm_mode->vsync_start - drm_mode->vdisplay, 380 drm_mode->vsync_end - drm_mode->vsync_start); 381 382 total_hor = drm_mode->htotal; 383 384 total_ver = drm_mode->vtotal; 385 386 data = total_ver; 387 data <<= 16; 388 data |= total_hor; 389 390 catalog->total = data; 391 392 data = (drm_mode->vtotal - drm_mode->vsync_start); 393 data <<= 16; 394 data |= (drm_mode->htotal - drm_mode->hsync_start); 395 396 catalog->sync_start = data; 397 398 data = drm_mode->vsync_end - drm_mode->vsync_start; 399 data <<= 16; 400 data |= (panel->dp_panel.dp_mode.v_active_low << 31); 401 data |= drm_mode->hsync_end - drm_mode->hsync_start; 402 data |= (panel->dp_panel.dp_mode.h_active_low << 15); 403 404 catalog->width_blanking = data; 405 406 data = drm_mode->vdisplay; 407 data <<= 16; 408 data |= drm_mode->hdisplay; 409 410 catalog->dp_active = data; 411 412 dp_catalog_panel_timing_cfg(catalog); 413 panel->panel_on = true; 414 415 return 0; 416 } 417 418 int dp_panel_init_panel_info(struct dp_panel *dp_panel) 419 { 420 struct drm_display_mode *drm_mode; 421 422 drm_mode = &dp_panel->dp_mode.drm_mode; 423 424 /* 425 * print resolution info as this is a result 426 * of user initiated action of cable connection 427 */ 428 DRM_DEBUG_DP("SET NEW RESOLUTION:\n"); 429 DRM_DEBUG_DP("%dx%d@%dfps\n", drm_mode->hdisplay, 430 drm_mode->vdisplay, drm_mode_vrefresh(drm_mode)); 431 DRM_DEBUG_DP("h_porches(back|front|width) = (%d|%d|%d)\n", 432 drm_mode->htotal - drm_mode->hsync_end, 433 drm_mode->hsync_start - drm_mode->hdisplay, 434 drm_mode->hsync_end - drm_mode->hsync_start); 435 DRM_DEBUG_DP("v_porches(back|front|width) = (%d|%d|%d)\n", 436 drm_mode->vtotal - drm_mode->vsync_end, 437 drm_mode->vsync_start - drm_mode->vdisplay, 438 drm_mode->vsync_end - drm_mode->vsync_start); 439 DRM_DEBUG_DP("pixel clock (KHz)=(%d)\n", drm_mode->clock); 440 DRM_DEBUG_DP("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_DEBUG_DP("updated bpp = %d\n", dp_panel->dp_mode.bpp); 445 446 return 0; 447 } 448 449 struct 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 475 void dp_panel_put(struct dp_panel *dp_panel) 476 { 477 if (!dp_panel) 478 return; 479 480 kfree(dp_panel->edid); 481 } 482