drivers/gpu/drm/msm/dp/dp_panel.c

   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 }