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