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