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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/module.h>
   7 #include <linux/slab.h>
   8 #include <linux/uaccess.h>
   9 #include <linux/debugfs.h>
  10 #include <linux/component.h>
  11 #include <linux/of_irq.h>
  12 #include <linux/delay.h>
  13 #include <drm/display/drm_dp_aux_bus.h>
  14
  15 #include "msm_drv.h"
  16 #include "msm_kms.h"
  17 #include "dp_hpd.h"
  18 #include "dp_parser.h"
  19 #include "dp_power.h"
  20 #include "dp_catalog.h"
  21 #include "dp_aux.h"
  22 #include "dp_reg.h"
  23 #include "dp_link.h"
  24 #include "dp_panel.h"
  25 #include "dp_ctrl.h"
  26 #include "dp_display.h"
  27 #include "dp_drm.h"
  28 #include "dp_audio.h"
  29 #include "dp_debug.h"
  30
  31 #define HPD_STRING_SIZE 30
  32
  33 enum {
  34         ISR_DISCONNECTED,
  35         ISR_CONNECT_PENDING,
  36         ISR_CONNECTED,
  37         ISR_HPD_REPLUG_COUNT,
  38         ISR_IRQ_HPD_PULSE_COUNT,
  39         ISR_HPD_LO_GLITH_COUNT,
  40 };
  41
  42 /* event thread connection state */
  43 enum {
  44         ST_DISCONNECTED,
  45         ST_MAINLINK_READY,
  46         ST_CONNECTED,
  47         ST_DISCONNECT_PENDING,
  48         ST_DISPLAY_OFF,
  49         ST_SUSPENDED,
  50 };
  51
  52 enum {
  53         EV_NO_EVENT,
  54         /* hpd events */
  55         EV_HPD_INIT_SETUP,
  56         EV_HPD_PLUG_INT,
  57         EV_IRQ_HPD_INT,
  58         EV_HPD_UNPLUG_INT,
  59         EV_USER_NOTIFICATION,
  60 };
  61
  62 #define EVENT_TIMEOUT   (HZ/10) /* 100ms */
  63 #define DP_EVENT_Q_MAX  8
  64
  65 #define DP_TIMEOUT_NONE         0
  66
  67 #define WAIT_FOR_RESUME_TIMEOUT_JIFFIES (HZ / 2)
  68
  69 struct dp_event {
  70         u32 event_id;
  71         u32 data;
  72         u32 delay;
  73 };
  74
  75 struct dp_display_private {
  76         char *name;
  77         int irq;
  78
  79         unsigned int id;
  80
  81         /* state variables */
  82         bool core_initialized;
  83         bool phy_initialized;
  84         bool hpd_irq_on;
  85         bool audio_supported;
  86
  87         struct drm_device *drm_dev;
  88         struct platform_device *pdev;
  89         struct dentry *root;
  90
  91         struct dp_usbpd   *usbpd;
  92         struct dp_parser  *parser;
  93         struct dp_power   *power;
  94         struct dp_catalog *catalog;
  95         struct drm_dp_aux *aux;
  96         struct dp_link    *link;
  97         struct dp_panel   *panel;
  98         struct dp_ctrl    *ctrl;
  99         struct dp_debug   *debug;
 100
 101         struct dp_usbpd_cb usbpd_cb;
 102         struct dp_display_mode dp_mode;
 103         struct msm_dp dp_display;
 104
 105         /* wait for audio signaling */
 106         struct completion audio_comp;
 107
 108         /* event related only access by event thread */
 109         struct mutex event_mutex;
 110         wait_queue_head_t event_q;
 111         u32 hpd_state;
 112         u32 event_pndx;
 113         u32 event_gndx;
 114         struct task_struct *ev_tsk;
 115         struct dp_event event_list[DP_EVENT_Q_MAX];
 116         spinlock_t event_lock;
 117
 118         bool wide_bus_en;
 119
 120         struct dp_audio *audio;
 121 };
 122
 123 struct msm_dp_desc {
 124         phys_addr_t io_start;
 125         unsigned int connector_type;
 126         bool wide_bus_en;
 127 };
 128
 129 struct msm_dp_config {
 130         const struct msm_dp_desc *descs;
 131         size_t num_descs;
 132 };
 133
 134 static const struct msm_dp_config sc7180_dp_cfg = {
 135         .descs = (const struct msm_dp_desc[]) {
 136                 [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
 137         },
 138         .num_descs = 1,
 139 };
 140
 141 static const struct msm_dp_config sc7280_dp_cfg = {
 142         .descs = (const struct msm_dp_desc[]) {
 143                 [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort, .wide_bus_en = true },
 144                 [MSM_DP_CONTROLLER_1] = { .io_start = 0x0aea0000, .connector_type = DRM_MODE_CONNECTOR_eDP, .wide_bus_en = true },
 145         },
 146         .num_descs = 2,
 147 };
 148
 149 static const struct msm_dp_config sc8180x_dp_cfg = {
 150         .descs = (const struct msm_dp_desc[]) {
 151                 [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
 152                 [MSM_DP_CONTROLLER_1] = { .io_start = 0x0ae98000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
 153                 [MSM_DP_CONTROLLER_2] = { .io_start = 0x0ae9a000, .connector_type = DRM_MODE_CONNECTOR_eDP },
 154         },
 155         .num_descs = 3,
 156 };
 157
 158 static const struct msm_dp_config sm8350_dp_cfg = {
 159         .descs = (const struct msm_dp_desc[]) {
 160                 [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
 161         },
 162         .num_descs = 1,
 163 };
 164
 165 static const struct of_device_id dp_dt_match[] = {
 166         { .compatible = "qcom,sc7180-dp", .data = &sc7180_dp_cfg },
 167         { .compatible = "qcom,sc7280-dp", .data = &sc7280_dp_cfg },
 168         { .compatible = "qcom,sc7280-edp", .data = &sc7280_dp_cfg },
 169         { .compatible = "qcom,sc8180x-dp", .data = &sc8180x_dp_cfg },
 170         { .compatible = "qcom,sc8180x-edp", .data = &sc8180x_dp_cfg },
 171         { .compatible = "qcom,sm8350-dp", .data = &sm8350_dp_cfg },
 172         {}
 173 };
 174
 175 static struct dp_display_private *dev_get_dp_display_private(struct device *dev)
 176 {
 177         struct msm_dp *dp = dev_get_drvdata(dev);
 178
 179         return container_of(dp, struct dp_display_private, dp_display);
 180 }
 181
 182 static int dp_add_event(struct dp_display_private *dp_priv, u32 event,
 183                                                 u32 data, u32 delay)
 184 {
 185         unsigned long flag;
 186         struct dp_event *todo;
 187         int pndx;
 188
 189         spin_lock_irqsave(&dp_priv->event_lock, flag);
 190         pndx = dp_priv->event_pndx + 1;
 191         pndx %= DP_EVENT_Q_MAX;
 192         if (pndx == dp_priv->event_gndx) {
 193                 pr_err("event_q is full: pndx=%d gndx=%d\n",
 194                         dp_priv->event_pndx, dp_priv->event_gndx);
 195                 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
 196                 return -EPERM;
 197         }
 198         todo = &dp_priv->event_list[dp_priv->event_pndx++];
 199         dp_priv->event_pndx %= DP_EVENT_Q_MAX;
 200         todo->event_id = event;
 201         todo->data = data;
 202         todo->delay = delay;
 203         wake_up(&dp_priv->event_q);
 204         spin_unlock_irqrestore(&dp_priv->event_lock, flag);
 205
 206         return 0;
 207 }
 208
 209 static int dp_del_event(struct dp_display_private *dp_priv, u32 event)
 210 {
 211         unsigned long flag;
 212         struct dp_event *todo;
 213         u32     gndx;
 214
 215         spin_lock_irqsave(&dp_priv->event_lock, flag);
 216         if (dp_priv->event_pndx == dp_priv->event_gndx) {
 217                 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
 218                 return -ENOENT;
 219         }
 220
 221         gndx = dp_priv->event_gndx;
 222         while (dp_priv->event_pndx != gndx) {
 223                 todo = &dp_priv->event_list[gndx];
 224                 if (todo->event_id == event) {
 225                         todo->event_id = EV_NO_EVENT;   /* deleted */
 226                         todo->delay = 0;
 227                 }
 228                 gndx++;
 229                 gndx %= DP_EVENT_Q_MAX;
 230         }
 231         spin_unlock_irqrestore(&dp_priv->event_lock, flag);
 232
 233         return 0;
 234 }
 235
 236 void dp_display_signal_audio_start(struct msm_dp *dp_display)
 237 {
 238         struct dp_display_private *dp;
 239
 240         dp = container_of(dp_display, struct dp_display_private, dp_display);
 241
 242         reinit_completion(&dp->audio_comp);
 243 }
 244
 245 void dp_display_signal_audio_complete(struct msm_dp *dp_display)
 246 {
 247         struct dp_display_private *dp;
 248
 249         dp = container_of(dp_display, struct dp_display_private, dp_display);
 250
 251         complete_all(&dp->audio_comp);
 252 }
 253
 254 static int dp_hpd_event_thread_start(struct dp_display_private *dp_priv);
 255
 256 static int dp_display_bind(struct device *dev, struct device *master,
 257                            void *data)
 258 {
 259         int rc = 0;
 260         struct dp_display_private *dp = dev_get_dp_display_private(dev);
 261         struct msm_drm_private *priv = dev_get_drvdata(master);
 262         struct drm_device *drm = priv->dev;
 263
 264         dp->dp_display.drm_dev = drm;
 265         priv->dp[dp->id] = &dp->dp_display;
 266
 267         rc = dp->parser->parse(dp->parser);
 268         if (rc) {
 269                 DRM_ERROR("device tree parsing failed\n");
 270                 goto end;
 271         }
 272
 273
 274         dp->drm_dev = drm;
 275         dp->aux->drm_dev = drm;
 276         rc = dp_aux_register(dp->aux);
 277         if (rc) {
 278                 DRM_ERROR("DRM DP AUX register failed\n");
 279                 goto end;
 280         }
 281
 282         rc = dp_power_client_init(dp->power);
 283         if (rc) {
 284                 DRM_ERROR("Power client create failed\n");
 285                 goto end;
 286         }
 287
 288         rc = dp_register_audio_driver(dev, dp->audio);
 289         if (rc) {
 290                 DRM_ERROR("Audio registration Dp failed\n");
 291                 goto end;
 292         }
 293
 294         rc = dp_hpd_event_thread_start(dp);
 295         if (rc) {
 296                 DRM_ERROR("Event thread create failed\n");
 297                 goto end;
 298         }
 299
 300         return 0;
 301 end:
 302         return rc;
 303 }
 304
 305 static void dp_display_unbind(struct device *dev, struct device *master,
 306                               void *data)
 307 {
 308         struct dp_display_private *dp = dev_get_dp_display_private(dev);
 309         struct msm_drm_private *priv = dev_get_drvdata(master);
 310
 311         /* disable all HPD interrupts */
 312         dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_INT_MASK, false);
 313
 314         kthread_stop(dp->ev_tsk);
 315
 316         dp_power_client_deinit(dp->power);
 317         dp_aux_unregister(dp->aux);
 318         priv->dp[dp->id] = NULL;
 319 }
 320
 321 static const struct component_ops dp_display_comp_ops = {
 322         .bind = dp_display_bind,
 323         .unbind = dp_display_unbind,
 324 };
 325
 326 static bool dp_display_is_ds_bridge(struct dp_panel *panel)
 327 {
 328         return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
 329                 DP_DWN_STRM_PORT_PRESENT);
 330 }
 331
 332 static bool dp_display_is_sink_count_zero(struct dp_display_private *dp)
 333 {
 334         drm_dbg_dp(dp->drm_dev, "present=%#x sink_count=%d\n",
 335                         dp->panel->dpcd[DP_DOWNSTREAMPORT_PRESENT],
 336                 dp->link->sink_count);
 337         return dp_display_is_ds_bridge(dp->panel) &&
 338                 (dp->link->sink_count == 0);
 339 }
 340
 341 static void dp_display_send_hpd_event(struct msm_dp *dp_display)
 342 {
 343         struct dp_display_private *dp;
 344         struct drm_connector *connector;
 345
 346         dp = container_of(dp_display, struct dp_display_private, dp_display);
 347
 348         connector = dp->dp_display.connector;
 349         drm_helper_hpd_irq_event(connector->dev);
 350 }
 351
 352
 353 static int dp_display_send_hpd_notification(struct dp_display_private *dp,
 354                                             bool hpd)
 355 {
 356         if ((hpd && dp->dp_display.is_connected) ||
 357                         (!hpd && !dp->dp_display.is_connected)) {
 358                 drm_dbg_dp(dp->drm_dev, "HPD already %s\n",
 359                                 (hpd ? "on" : "off"));
 360                 return 0;
 361         }
 362
 363         /* reset video pattern flag on disconnect */
 364         if (!hpd)
 365                 dp->panel->video_test = false;
 366
 367         dp->dp_display.is_connected = hpd;
 368
 369         drm_dbg_dp(dp->drm_dev, "type=%d hpd=%d\n",
 370                         dp->dp_display.connector_type, hpd);
 371         dp_display_send_hpd_event(&dp->dp_display);
 372
 373         return 0;
 374 }
 375
 376 static int dp_display_process_hpd_high(struct dp_display_private *dp)
 377 {
 378         int rc = 0;
 379         struct edid *edid;
 380
 381         dp->panel->max_dp_lanes = dp->parser->max_dp_lanes;
 382
 383         rc = dp_panel_read_sink_caps(dp->panel, dp->dp_display.connector);
 384         if (rc)
 385                 goto end;
 386
 387         dp_link_process_request(dp->link);
 388
 389         edid = dp->panel->edid;
 390
 391         dp->audio_supported = drm_detect_monitor_audio(edid);
 392         dp_panel_handle_sink_request(dp->panel);
 393
 394         dp->dp_display.max_dp_lanes = dp->parser->max_dp_lanes;
 395
 396         /*
 397          * set sink to normal operation mode -- D0
 398          * before dpcd read
 399          */
 400         dp_link_psm_config(dp->link, &dp->panel->link_info, false);
 401
 402         dp_link_reset_phy_params_vx_px(dp->link);
 403         rc = dp_ctrl_on_link(dp->ctrl);
 404         if (rc) {
 405                 DRM_ERROR("failed to complete DP link training\n");
 406                 goto end;
 407         }
 408
 409         dp_add_event(dp, EV_USER_NOTIFICATION, true, 0);
 410
 411 end:
 412         return rc;
 413 }
 414
 415 static void dp_display_host_phy_init(struct dp_display_private *dp)
 416 {
 417         drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
 418                 dp->dp_display.connector_type, dp->core_initialized,
 419                 dp->phy_initialized);
 420
 421         if (!dp->phy_initialized) {
 422                 dp_ctrl_phy_init(dp->ctrl);
 423                 dp->phy_initialized = true;
 424         }
 425 }
 426
 427 static void dp_display_host_phy_exit(struct dp_display_private *dp)
 428 {
 429         drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
 430                 dp->dp_display.connector_type, dp->core_initialized,
 431                 dp->phy_initialized);
 432
 433         if (dp->phy_initialized) {
 434                 dp_ctrl_phy_exit(dp->ctrl);
 435                 dp->phy_initialized = false;
 436         }
 437 }
 438
 439 static void dp_display_host_init(struct dp_display_private *dp)
 440 {
 441         drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
 442                 dp->dp_display.connector_type, dp->core_initialized,
 443                 dp->phy_initialized);
 444
 445         dp_power_init(dp->power, false);
 446         dp_ctrl_reset_irq_ctrl(dp->ctrl, true);
 447         dp_aux_init(dp->aux);
 448         dp->core_initialized = true;
 449 }
 450
 451 static void dp_display_host_deinit(struct dp_display_private *dp)
 452 {
 453         drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
 454                 dp->dp_display.connector_type, dp->core_initialized,
 455                 dp->phy_initialized);
 456
 457         dp_ctrl_reset_irq_ctrl(dp->ctrl, false);
 458         dp_aux_deinit(dp->aux);
 459         dp_power_deinit(dp->power);
 460         dp->core_initialized = false;
 461 }
 462
 463 static int dp_display_usbpd_configure_cb(struct device *dev)
 464 {
 465         struct dp_display_private *dp = dev_get_dp_display_private(dev);
 466
 467         dp_display_host_phy_init(dp);
 468
 469         return dp_display_process_hpd_high(dp);
 470 }
 471
 472 static int dp_display_usbpd_disconnect_cb(struct device *dev)
 473 {
 474         return 0;
 475 }
 476
 477 static int dp_display_notify_disconnect(struct device *dev)
 478 {
 479         struct dp_display_private *dp = dev_get_dp_display_private(dev);
 480
 481         dp_add_event(dp, EV_USER_NOTIFICATION, false, 0);
 482
 483         return 0;
 484 }
 485
 486 static void dp_display_handle_video_request(struct dp_display_private *dp)
 487 {
 488         if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
 489                 dp->panel->video_test = true;
 490                 dp_link_send_test_response(dp->link);
 491         }
 492 }
 493
 494 static int dp_display_handle_port_ststus_changed(struct dp_display_private *dp)
 495 {
 496         int rc = 0;
 497
 498         if (dp_display_is_sink_count_zero(dp)) {
 499                 drm_dbg_dp(dp->drm_dev, "sink count is zero, nothing to do\n");
 500                 if (dp->hpd_state != ST_DISCONNECTED) {
 501                         dp->hpd_state = ST_DISCONNECT_PENDING;
 502                         dp_add_event(dp, EV_USER_NOTIFICATION, false, 0);
 503                 }
 504         } else {
 505                 if (dp->hpd_state == ST_DISCONNECTED) {
 506                         dp->hpd_state = ST_MAINLINK_READY;
 507                         rc = dp_display_process_hpd_high(dp);
 508                         if (rc)
 509                                 dp->hpd_state = ST_DISCONNECTED;
 510                 }
 511         }
 512
 513         return rc;
 514 }
 515
 516 static int dp_display_handle_irq_hpd(struct dp_display_private *dp)
 517 {
 518         u32 sink_request = dp->link->sink_request;
 519
 520         drm_dbg_dp(dp->drm_dev, "%d\n", sink_request);
 521         if (dp->hpd_state == ST_DISCONNECTED) {
 522                 if (sink_request & DP_LINK_STATUS_UPDATED) {
 523                         drm_dbg_dp(dp->drm_dev, "Disconnected sink_request: %d\n",
 524                                                         sink_request);
 525                         DRM_ERROR("Disconnected, no DP_LINK_STATUS_UPDATED\n");
 526                         return -EINVAL;
 527                 }
 528         }
 529
 530         dp_ctrl_handle_sink_request(dp->ctrl);
 531
 532         if (sink_request & DP_TEST_LINK_VIDEO_PATTERN)
 533                 dp_display_handle_video_request(dp);
 534
 535         return 0;
 536 }
 537
 538 static int dp_display_usbpd_attention_cb(struct device *dev)
 539 {
 540         int rc = 0;
 541         u32 sink_request;
 542         struct dp_display_private *dp = dev_get_dp_display_private(dev);
 543
 544         /* check for any test request issued by sink */
 545         rc = dp_link_process_request(dp->link);
 546         if (!rc) {
 547                 sink_request = dp->link->sink_request;
 548                 drm_dbg_dp(dp->drm_dev, "hpd_state=%d sink_request=%d\n",
 549                                         dp->hpd_state, sink_request);
 550                 if (sink_request & DS_PORT_STATUS_CHANGED)
 551                         rc = dp_display_handle_port_ststus_changed(dp);
 552                 else
 553                         rc = dp_display_handle_irq_hpd(dp);
 554         }
 555
 556         return rc;
 557 }
 558
 559 static int dp_hpd_plug_handle(struct dp_display_private *dp, u32 data)
 560 {
 561         struct dp_usbpd *hpd = dp->usbpd;
 562         u32 state;
 563         int ret;
 564
 565         if (!hpd)
 566                 return 0;
 567
 568         mutex_lock(&dp->event_mutex);
 569
 570         state =  dp->hpd_state;
 571         drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n",
 572                         dp->dp_display.connector_type, state);
 573
 574         if (state == ST_DISPLAY_OFF || state == ST_SUSPENDED) {
 575                 mutex_unlock(&dp->event_mutex);
 576                 return 0;
 577         }
 578
 579         if (state == ST_MAINLINK_READY || state == ST_CONNECTED) {
 580                 mutex_unlock(&dp->event_mutex);
 581                 return 0;
 582         }
 583
 584         if (state == ST_DISCONNECT_PENDING) {
 585                 /* wait until ST_DISCONNECTED */
 586                 dp_add_event(dp, EV_HPD_PLUG_INT, 0, 1); /* delay = 1 */
 587                 mutex_unlock(&dp->event_mutex);
 588                 return 0;
 589         }
 590
 591         ret = dp_display_usbpd_configure_cb(&dp->pdev->dev);
 592         if (ret) {      /* link train failed */
 593                 dp->hpd_state = ST_DISCONNECTED;
 594         } else {
 595                 dp->hpd_state = ST_MAINLINK_READY;
 596         }
 597
 598         /* enable HDP irq_hpd/replug interrupt */
 599         dp_catalog_hpd_config_intr(dp->catalog,
 600                 DP_DP_IRQ_HPD_INT_MASK | DP_DP_HPD_REPLUG_INT_MASK, true);
 601
 602         drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n",
 603                         dp->dp_display.connector_type, state);
 604         mutex_unlock(&dp->event_mutex);
 605
 606         /* uevent will complete connection part */
 607         return 0;
 608 };
 609
 610 static int dp_display_enable(struct dp_display_private *dp, u32 data);
 611 static int dp_display_disable(struct dp_display_private *dp, u32 data);
 612
 613 static void dp_display_handle_plugged_change(struct msm_dp *dp_display,
 614                 bool plugged)
 615 {
 616         struct dp_display_private *dp;
 617
 618         dp = container_of(dp_display,
 619                         struct dp_display_private, dp_display);
 620
 621         /* notify audio subsystem only if sink supports audio */
 622         if (dp_display->plugged_cb && dp_display->codec_dev &&
 623                         dp->audio_supported)
 624                 dp_display->plugged_cb(dp_display->codec_dev, plugged);
 625 }
 626
 627 static int dp_hpd_unplug_handle(struct dp_display_private *dp, u32 data)
 628 {
 629         struct dp_usbpd *hpd = dp->usbpd;
 630         u32 state;
 631
 632         if (!hpd)
 633                 return 0;
 634
 635         mutex_lock(&dp->event_mutex);
 636
 637         state = dp->hpd_state;
 638
 639         drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n",
 640                         dp->dp_display.connector_type, state);
 641
 642         /* disable irq_hpd/replug interrupts */
 643         dp_catalog_hpd_config_intr(dp->catalog,
 644                 DP_DP_IRQ_HPD_INT_MASK | DP_DP_HPD_REPLUG_INT_MASK, false);
 645
 646         /* unplugged, no more irq_hpd handle */
 647         dp_del_event(dp, EV_IRQ_HPD_INT);
 648
 649         if (state == ST_DISCONNECTED) {
 650                 /* triggered by irq_hdp with sink_count = 0 */
 651                 if (dp->link->sink_count == 0) {
 652                         dp_display_host_phy_exit(dp);
 653                 }
 654                 dp_display_notify_disconnect(&dp->pdev->dev);
 655                 mutex_unlock(&dp->event_mutex);
 656                 return 0;
 657         } else if (state == ST_DISCONNECT_PENDING) {
 658                 mutex_unlock(&dp->event_mutex);
 659                 return 0;
 660         } else if (state == ST_MAINLINK_READY) {
 661                 dp_ctrl_off_link(dp->ctrl);
 662                 dp_display_host_phy_exit(dp);
 663                 dp->hpd_state = ST_DISCONNECTED;
 664                 dp_display_notify_disconnect(&dp->pdev->dev);
 665                 mutex_unlock(&dp->event_mutex);
 666                 return 0;
 667         }
 668
 669         /* disable HPD plug interrupts */
 670         dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK, false);
 671
 672         /*
 673          * We don't need separate work for disconnect as
 674          * connect/attention interrupts are disabled
 675          */
 676         dp_display_notify_disconnect(&dp->pdev->dev);
 677
 678         if (state == ST_DISPLAY_OFF) {
 679                 dp->hpd_state = ST_DISCONNECTED;
 680         } else {
 681                 dp->hpd_state = ST_DISCONNECT_PENDING;
 682         }
 683
 684         /* signal the disconnect event early to ensure proper teardown */
 685         dp_display_handle_plugged_change(&dp->dp_display, false);
 686
 687         /* enable HDP plug interrupt to prepare for next plugin */
 688         if (!dp->dp_display.is_edp)
 689                 dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK, true);
 690
 691         drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n",
 692                         dp->dp_display.connector_type, state);
 693
 694         /* uevent will complete disconnection part */
 695         mutex_unlock(&dp->event_mutex);
 696         return 0;
 697 }
 698
 699 static int dp_irq_hpd_handle(struct dp_display_private *dp, u32 data)
 700 {
 701         u32 state;
 702
 703         mutex_lock(&dp->event_mutex);
 704
 705         /* irq_hpd can happen at either connected or disconnected state */
 706         state =  dp->hpd_state;
 707         drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n",
 708                         dp->dp_display.connector_type, state);
 709
 710         if (state == ST_DISPLAY_OFF || state == ST_SUSPENDED) {
 711                 mutex_unlock(&dp->event_mutex);
 712                 return 0;
 713         }
 714
 715         if (state == ST_MAINLINK_READY || state == ST_DISCONNECT_PENDING) {
 716                 /* wait until ST_CONNECTED */
 717                 dp_add_event(dp, EV_IRQ_HPD_INT, 0, 1); /* delay = 1 */
 718                 mutex_unlock(&dp->event_mutex);
 719                 return 0;
 720         }
 721
 722         dp_display_usbpd_attention_cb(&dp->pdev->dev);
 723
 724         drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n",
 725                         dp->dp_display.connector_type, state);
 726
 727         mutex_unlock(&dp->event_mutex);
 728
 729         return 0;
 730 }
 731
 732 static void dp_display_deinit_sub_modules(struct dp_display_private *dp)
 733 {
 734         dp_debug_put(dp->debug);
 735         dp_audio_put(dp->audio);
 736         dp_panel_put(dp->panel);
 737         dp_aux_put(dp->aux);
 738 }
 739
 740 static int dp_init_sub_modules(struct dp_display_private *dp)
 741 {
 742         int rc = 0;
 743         struct device *dev = &dp->pdev->dev;
 744         struct dp_usbpd_cb *cb = &dp->usbpd_cb;
 745         struct dp_panel_in panel_in = {
 746                 .dev = dev,
 747         };
 748
 749         /* Callback APIs used for cable status change event */
 750         cb->configure  = dp_display_usbpd_configure_cb;
 751         cb->disconnect = dp_display_usbpd_disconnect_cb;
 752         cb->attention  = dp_display_usbpd_attention_cb;
 753
 754         dp->usbpd = dp_hpd_get(dev, cb);
 755         if (IS_ERR(dp->usbpd)) {
 756                 rc = PTR_ERR(dp->usbpd);
 757                 DRM_ERROR("failed to initialize hpd, rc = %d\n", rc);
 758                 dp->usbpd = NULL;
 759                 goto error;
 760         }
 761
 762         dp->parser = dp_parser_get(dp->pdev);
 763         if (IS_ERR(dp->parser)) {
 764                 rc = PTR_ERR(dp->parser);
 765                 DRM_ERROR("failed to initialize parser, rc = %d\n", rc);
 766                 dp->parser = NULL;
 767                 goto error;
 768         }
 769
 770         dp->catalog = dp_catalog_get(dev, &dp->parser->io);
 771         if (IS_ERR(dp->catalog)) {
 772                 rc = PTR_ERR(dp->catalog);
 773                 DRM_ERROR("failed to initialize catalog, rc = %d\n", rc);
 774                 dp->catalog = NULL;
 775                 goto error;
 776         }
 777
 778         dp->power = dp_power_get(dev, dp->parser);
 779         if (IS_ERR(dp->power)) {
 780                 rc = PTR_ERR(dp->power);
 781                 DRM_ERROR("failed to initialize power, rc = %d\n", rc);
 782                 dp->power = NULL;
 783                 goto error;
 784         }
 785
 786         dp->aux = dp_aux_get(dev, dp->catalog, dp->dp_display.is_edp);
 787         if (IS_ERR(dp->aux)) {
 788                 rc = PTR_ERR(dp->aux);
 789                 DRM_ERROR("failed to initialize aux, rc = %d\n", rc);
 790                 dp->aux = NULL;
 791                 goto error;
 792         }
 793
 794         dp->link = dp_link_get(dev, dp->aux);
 795         if (IS_ERR(dp->link)) {
 796                 rc = PTR_ERR(dp->link);
 797                 DRM_ERROR("failed to initialize link, rc = %d\n", rc);
 798                 dp->link = NULL;
 799                 goto error_link;
 800         }
 801
 802         panel_in.aux = dp->aux;
 803         panel_in.catalog = dp->catalog;
 804         panel_in.link = dp->link;
 805
 806         dp->panel = dp_panel_get(&panel_in);
 807         if (IS_ERR(dp->panel)) {
 808                 rc = PTR_ERR(dp->panel);
 809                 DRM_ERROR("failed to initialize panel, rc = %d\n", rc);
 810                 dp->panel = NULL;
 811                 goto error_link;
 812         }
 813
 814         dp->ctrl = dp_ctrl_get(dev, dp->link, dp->panel, dp->aux,
 815                                dp->power, dp->catalog, dp->parser);
 816         if (IS_ERR(dp->ctrl)) {
 817                 rc = PTR_ERR(dp->ctrl);
 818                 DRM_ERROR("failed to initialize ctrl, rc = %d\n", rc);
 819                 dp->ctrl = NULL;
 820                 goto error_ctrl;
 821         }
 822
 823         dp->audio = dp_audio_get(dp->pdev, dp->panel, dp->catalog);
 824         if (IS_ERR(dp->audio)) {
 825                 rc = PTR_ERR(dp->audio);
 826                 pr_err("failed to initialize audio, rc = %d\n", rc);
 827                 dp->audio = NULL;
 828                 goto error_ctrl;
 829         }
 830
 831         /* populate wide_bus_en to differernt layers */
 832         dp->ctrl->wide_bus_en = dp->wide_bus_en;
 833         dp->catalog->wide_bus_en = dp->wide_bus_en;
 834
 835         return rc;
 836
 837 error_ctrl:
 838         dp_panel_put(dp->panel);
 839 error_link:
 840         dp_aux_put(dp->aux);
 841 error:
 842         return rc;
 843 }
 844
 845 static int dp_display_set_mode(struct msm_dp *dp_display,
 846                                struct dp_display_mode *mode)
 847 {
 848         struct dp_display_private *dp;
 849
 850         dp = container_of(dp_display, struct dp_display_private, dp_display);
 851
 852         dp->panel->dp_mode.drm_mode = mode->drm_mode;
 853         dp->panel->dp_mode.bpp = mode->bpp;
 854         dp->panel->dp_mode.capabilities = mode->capabilities;
 855         dp_panel_init_panel_info(dp->panel);
 856         return 0;
 857 }
 858
 859 static int dp_display_prepare(struct msm_dp *dp_display)
 860 {
 861         return 0;
 862 }
 863
 864 static int dp_display_enable(struct dp_display_private *dp, u32 data)
 865 {
 866         int rc = 0;
 867         struct msm_dp *dp_display = &dp->dp_display;
 868
 869         drm_dbg_dp(dp->drm_dev, "sink_count=%d\n", dp->link->sink_count);
 870         if (dp_display->power_on) {
 871                 drm_dbg_dp(dp->drm_dev, "Link already setup, return\n");
 872                 return 0;
 873         }
 874
 875         rc = dp_ctrl_on_stream(dp->ctrl);
 876         if (!rc)
 877                 dp_display->power_on = true;
 878
 879         return rc;
 880 }
 881
 882 static int dp_display_post_enable(struct msm_dp *dp_display)
 883 {
 884         struct dp_display_private *dp;
 885         u32 rate;
 886
 887         dp = container_of(dp_display, struct dp_display_private, dp_display);
 888
 889         rate = dp->link->link_params.rate;
 890
 891         if (dp->audio_supported) {
 892                 dp->audio->bw_code = drm_dp_link_rate_to_bw_code(rate);
 893                 dp->audio->lane_count = dp->link->link_params.num_lanes;
 894         }
 895
 896         /* signal the connect event late to synchronize video and display */
 897         dp_display_handle_plugged_change(dp_display, true);
 898         return 0;
 899 }
 900
 901 static int dp_display_disable(struct dp_display_private *dp, u32 data)
 902 {
 903         struct msm_dp *dp_display = &dp->dp_display;
 904
 905         if (!dp_display->power_on)
 906                 return 0;
 907
 908         /* wait only if audio was enabled */
 909         if (dp_display->audio_enabled) {
 910                 /* signal the disconnect event */
 911                 dp_display_handle_plugged_change(dp_display, false);
 912                 if (!wait_for_completion_timeout(&dp->audio_comp,
 913                                 HZ * 5))
 914                         DRM_ERROR("audio comp timeout\n");
 915         }
 916
 917         dp_display->audio_enabled = false;
 918
 919         if (dp->link->sink_count == 0) {
 920                 /*
 921                  * irq_hpd with sink_count = 0
 922                  * hdmi unplugged out of dongle
 923                  */
 924                 dp_ctrl_off_link_stream(dp->ctrl);
 925         } else {
 926                 /*
 927                  * unplugged interrupt
 928                  * dongle unplugged out of DUT
 929                  */
 930                 dp_ctrl_off(dp->ctrl);
 931                 dp_display_host_phy_exit(dp);
 932         }
 933
 934         dp_display->power_on = false;
 935
 936         drm_dbg_dp(dp->drm_dev, "sink count: %d\n", dp->link->sink_count);
 937         return 0;
 938 }
 939
 940 static int dp_display_unprepare(struct msm_dp *dp_display)
 941 {
 942         return 0;
 943 }
 944
 945 int dp_display_set_plugged_cb(struct msm_dp *dp_display,
 946                 hdmi_codec_plugged_cb fn, struct device *codec_dev)
 947 {
 948         bool plugged;
 949
 950         dp_display->plugged_cb = fn;
 951         dp_display->codec_dev = codec_dev;
 952         plugged = dp_display->is_connected;
 953         dp_display_handle_plugged_change(dp_display, plugged);
 954
 955         return 0;
 956 }
 957
 958 /**
 959  * dp_bridge_mode_valid - callback to determine if specified mode is valid
 960  * @bridge: Pointer to drm bridge structure
 961  * @info: display info
 962  * @mode: Pointer to drm mode structure
 963  * Returns: Validity status for specified mode
 964  */
 965 enum drm_mode_status dp_bridge_mode_valid(struct drm_bridge *bridge,
 966                                           const struct drm_display_info *info,
 967                                           const struct drm_display_mode *mode)
 968 {
 969         const u32 num_components = 3, default_bpp = 24;
 970         struct dp_display_private *dp_display;
 971         struct dp_link_info *link_info;
 972         u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
 973         struct msm_dp *dp;
 974         int mode_pclk_khz = mode->clock;
 975
 976         dp = to_dp_bridge(bridge)->dp_display;
 977
 978         if (!dp || !mode_pclk_khz || !dp->connector) {
 979                 DRM_ERROR("invalid params\n");
 980                 return -EINVAL;
 981         }
 982
 983         /*
 984          * The eDP controller currently does not have a reliable way of
 985          * enabling panel power to read sink capabilities. So, we rely
 986          * on the panel driver to populate only supported modes for now.
 987          */
 988         if (dp->is_edp)
 989                 return MODE_OK;
 990
 991         if (mode->clock > DP_MAX_PIXEL_CLK_KHZ)
 992                 return MODE_BAD;
 993
 994         dp_display = container_of(dp, struct dp_display_private, dp_display);
 995         link_info = &dp_display->panel->link_info;
 996
 997         mode_bpp = dp->connector->display_info.bpc * num_components;
 998         if (!mode_bpp)
 999                 mode_bpp = default_bpp;
1000
1001         mode_bpp = dp_panel_get_mode_bpp(dp_display->panel,
1002                         mode_bpp, mode_pclk_khz);
1003
1004         mode_rate_khz = mode_pclk_khz * mode_bpp;
1005         supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
1006
1007         if (mode_rate_khz > supported_rate_khz)
1008                 return MODE_BAD;
1009
1010         return MODE_OK;
1011 }
1012
1013 int dp_display_get_modes(struct msm_dp *dp)
1014 {
1015         struct dp_display_private *dp_display;
1016
1017         if (!dp) {
1018                 DRM_ERROR("invalid params\n");
1019                 return 0;
1020         }
1021
1022         dp_display = container_of(dp, struct dp_display_private, dp_display);
1023
1024         return dp_panel_get_modes(dp_display->panel,
1025                 dp->connector);
1026 }
1027
1028 bool dp_display_check_video_test(struct msm_dp *dp)
1029 {
1030         struct dp_display_private *dp_display;
1031
1032         dp_display = container_of(dp, struct dp_display_private, dp_display);
1033
1034         return dp_display->panel->video_test;
1035 }
1036
1037 int dp_display_get_test_bpp(struct msm_dp *dp)
1038 {
1039         struct dp_display_private *dp_display;
1040
1041         if (!dp) {
1042                 DRM_ERROR("invalid params\n");
1043                 return 0;
1044         }
1045
1046         dp_display = container_of(dp, struct dp_display_private, dp_display);
1047
1048         return dp_link_bit_depth_to_bpp(
1049                 dp_display->link->test_video.test_bit_depth);
1050 }
1051
1052 void msm_dp_snapshot(struct msm_disp_state *disp_state, struct msm_dp *dp)
1053 {
1054         struct dp_display_private *dp_display;
1055
1056         dp_display = container_of(dp, struct dp_display_private, dp_display);
1057
1058         /*
1059          * if we are reading registers we need the link clocks to be on
1060          * however till DP cable is connected this will not happen as we
1061          * do not know the resolution to power up with. Hence check the
1062          * power_on status before dumping DP registers to avoid crash due
1063          * to unclocked access
1064          */
1065         mutex_lock(&dp_display->event_mutex);
1066
1067         if (!dp->power_on) {
1068                 mutex_unlock(&dp_display->event_mutex);
1069                 return;
1070         }
1071
1072         dp_catalog_snapshot(dp_display->catalog, disp_state);
1073
1074         mutex_unlock(&dp_display->event_mutex);
1075 }
1076
1077 static void dp_display_config_hpd(struct dp_display_private *dp)
1078 {
1079
1080         dp_display_host_init(dp);
1081         dp_catalog_ctrl_hpd_config(dp->catalog);
1082
1083         /* Enable plug and unplug interrupts only for external DisplayPort */
1084         if (!dp->dp_display.is_edp)
1085                 dp_catalog_hpd_config_intr(dp->catalog,
1086                                 DP_DP_HPD_PLUG_INT_MASK |
1087                                 DP_DP_HPD_UNPLUG_INT_MASK,
1088                                 true);
1089
1090         /* Enable interrupt first time
1091          * we are leaving dp clocks on during disconnect
1092          * and never disable interrupt
1093          */
1094         enable_irq(dp->irq);
1095 }
1096
1097 static int hpd_event_thread(void *data)
1098 {
1099         struct dp_display_private *dp_priv;
1100         unsigned long flag;
1101         struct dp_event *todo;
1102         int timeout_mode = 0;
1103
1104         dp_priv = (struct dp_display_private *)data;
1105
1106         while (1) {
1107                 if (timeout_mode) {
1108                         wait_event_timeout(dp_priv->event_q,
1109                                 (dp_priv->event_pndx == dp_priv->event_gndx) ||
1110                                         kthread_should_stop(), EVENT_TIMEOUT);
1111                 } else {
1112                         wait_event_interruptible(dp_priv->event_q,
1113                                 (dp_priv->event_pndx != dp_priv->event_gndx) ||
1114                                         kthread_should_stop());
1115                 }
1116
1117                 if (kthread_should_stop())
1118                         break;
1119
1120                 spin_lock_irqsave(&dp_priv->event_lock, flag);
1121                 todo = &dp_priv->event_list[dp_priv->event_gndx];
1122                 if (todo->delay) {
1123                         struct dp_event *todo_next;
1124
1125                         dp_priv->event_gndx++;
1126                         dp_priv->event_gndx %= DP_EVENT_Q_MAX;
1127
1128                         /* re enter delay event into q */
1129                         todo_next = &dp_priv->event_list[dp_priv->event_pndx++];
1130                         dp_priv->event_pndx %= DP_EVENT_Q_MAX;
1131                         todo_next->event_id = todo->event_id;
1132                         todo_next->data = todo->data;
1133                         todo_next->delay = todo->delay - 1;
1134
1135                         /* clean up older event */
1136                         todo->event_id = EV_NO_EVENT;
1137                         todo->delay = 0;
1138
1139                         /* switch to timeout mode */
1140                         timeout_mode = 1;
1141                         spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1142                         continue;
1143                 }
1144
1145                 /* timeout with no events in q */
1146                 if (dp_priv->event_pndx == dp_priv->event_gndx) {
1147                         spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1148                         continue;
1149                 }
1150
1151                 dp_priv->event_gndx++;
1152                 dp_priv->event_gndx %= DP_EVENT_Q_MAX;
1153                 timeout_mode = 0;
1154                 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1155
1156                 switch (todo->event_id) {
1157                 case EV_HPD_INIT_SETUP:
1158                         dp_display_config_hpd(dp_priv);
1159                         break;
1160                 case EV_HPD_PLUG_INT:
1161                         dp_hpd_plug_handle(dp_priv, todo->data);
1162                         break;
1163                 case EV_HPD_UNPLUG_INT:
1164                         dp_hpd_unplug_handle(dp_priv, todo->data);
1165                         break;
1166                 case EV_IRQ_HPD_INT:
1167                         dp_irq_hpd_handle(dp_priv, todo->data);
1168                         break;
1169                 case EV_USER_NOTIFICATION:
1170                         dp_display_send_hpd_notification(dp_priv,
1171                                                 todo->data);
1172                         break;
1173                 default:
1174                         break;
1175                 }
1176         }
1177
1178         return 0;
1179 }
1180
1181 static int dp_hpd_event_thread_start(struct dp_display_private *dp_priv)
1182 {
1183         /* set event q to empty */
1184         dp_priv->event_gndx = 0;
1185         dp_priv->event_pndx = 0;
1186
1187         dp_priv->ev_tsk = kthread_run(hpd_event_thread, dp_priv, "dp_hpd_handler");
1188         if (IS_ERR(dp_priv->ev_tsk))
1189                 return PTR_ERR(dp_priv->ev_tsk);
1190
1191         return 0;
1192 }
1193
1194 static irqreturn_t dp_display_irq_handler(int irq, void *dev_id)
1195 {
1196         struct dp_display_private *dp = dev_id;
1197         irqreturn_t ret = IRQ_HANDLED;
1198         u32 hpd_isr_status;
1199
1200         if (!dp) {
1201                 DRM_ERROR("invalid data\n");
1202                 return IRQ_NONE;
1203         }
1204
1205         hpd_isr_status = dp_catalog_hpd_get_intr_status(dp->catalog);
1206
1207         if (hpd_isr_status & 0x0F) {
1208                 drm_dbg_dp(dp->drm_dev, "type=%d isr=0x%x\n",
1209                         dp->dp_display.connector_type, hpd_isr_status);
1210                 /* hpd related interrupts */
1211                 if (hpd_isr_status & DP_DP_HPD_PLUG_INT_MASK)
1212                         dp_add_event(dp, EV_HPD_PLUG_INT, 0, 0);
1213
1214                 if (hpd_isr_status & DP_DP_IRQ_HPD_INT_MASK) {
1215                         dp_add_event(dp, EV_IRQ_HPD_INT, 0, 0);
1216                 }
1217
1218                 if (hpd_isr_status & DP_DP_HPD_REPLUG_INT_MASK) {
1219                         dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0);
1220                         dp_add_event(dp, EV_HPD_PLUG_INT, 0, 3);
1221                 }
1222
1223                 if (hpd_isr_status & DP_DP_HPD_UNPLUG_INT_MASK)
1224                         dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0);
1225         }
1226
1227         /* DP controller isr */
1228         dp_ctrl_isr(dp->ctrl);
1229
1230         /* DP aux isr */
1231         dp_aux_isr(dp->aux);
1232
1233         return ret;
1234 }
1235
1236 int dp_display_request_irq(struct msm_dp *dp_display)
1237 {
1238         int rc = 0;
1239         struct dp_display_private *dp;
1240
1241         if (!dp_display) {
1242                 DRM_ERROR("invalid input\n");
1243                 return -EINVAL;
1244         }
1245
1246         dp = container_of(dp_display, struct dp_display_private, dp_display);
1247
1248         dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
1249         if (!dp->irq) {
1250                 DRM_ERROR("failed to get irq\n");
1251                 return -EINVAL;
1252         }
1253
1254         rc = devm_request_irq(&dp->pdev->dev, dp->irq,
1255                         dp_display_irq_handler,
1256                         IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
1257         if (rc < 0) {
1258                 DRM_ERROR("failed to request IRQ%u: %d\n",
1259                                 dp->irq, rc);
1260                 return rc;
1261         }
1262         disable_irq(dp->irq);
1263
1264         return 0;
1265 }
1266
1267 static const struct msm_dp_desc *dp_display_get_desc(struct platform_device *pdev,
1268                                                      unsigned int *id)
1269 {
1270         const struct msm_dp_config *cfg = of_device_get_match_data(&pdev->dev);
1271         struct resource *res;
1272         int i;
1273
1274         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1275         if (!res)
1276                 return NULL;
1277
1278         for (i = 0; i < cfg->num_descs; i++) {
1279                 if (cfg->descs[i].io_start == res->start) {
1280                         *id = i;
1281                         return &cfg->descs[i];
1282                 }
1283         }
1284
1285         dev_err(&pdev->dev, "unknown displayport instance\n");
1286         return NULL;
1287 }
1288
1289 static int dp_display_probe(struct platform_device *pdev)
1290 {
1291         int rc = 0;
1292         struct dp_display_private *dp;
1293         const struct msm_dp_desc *desc;
1294
1295         if (!pdev || !pdev->dev.of_node) {
1296                 DRM_ERROR("pdev not found\n");
1297                 return -ENODEV;
1298         }
1299
1300         dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
1301         if (!dp)
1302                 return -ENOMEM;
1303
1304         desc = dp_display_get_desc(pdev, &dp->id);
1305         if (!desc)
1306                 return -EINVAL;
1307
1308         dp->pdev = pdev;
1309         dp->name = "drm_dp";
1310         dp->dp_display.connector_type = desc->connector_type;
1311         dp->wide_bus_en = desc->wide_bus_en;
1312         dp->dp_display.is_edp =
1313                 (dp->dp_display.connector_type == DRM_MODE_CONNECTOR_eDP);
1314
1315         rc = dp_init_sub_modules(dp);
1316         if (rc) {
1317                 DRM_ERROR("init sub module failed\n");
1318                 return -EPROBE_DEFER;
1319         }
1320
1321         /* setup event q */
1322         mutex_init(&dp->event_mutex);
1323         init_waitqueue_head(&dp->event_q);
1324         spin_lock_init(&dp->event_lock);
1325
1326         /* Store DP audio handle inside DP display */
1327         dp->dp_display.dp_audio = dp->audio;
1328
1329         init_completion(&dp->audio_comp);
1330
1331         platform_set_drvdata(pdev, &dp->dp_display);
1332
1333         rc = component_add(&pdev->dev, &dp_display_comp_ops);
1334         if (rc) {
1335                 DRM_ERROR("component add failed, rc=%d\n", rc);
1336                 dp_display_deinit_sub_modules(dp);
1337         }
1338
1339         return rc;
1340 }
1341
1342 static int dp_display_remove(struct platform_device *pdev)
1343 {
1344         struct dp_display_private *dp = dev_get_dp_display_private(&pdev->dev);
1345
1346         dp_display_deinit_sub_modules(dp);
1347
1348         component_del(&pdev->dev, &dp_display_comp_ops);
1349         platform_set_drvdata(pdev, NULL);
1350
1351         return 0;
1352 }
1353
1354 static int dp_pm_resume(struct device *dev)
1355 {
1356         struct platform_device *pdev = to_platform_device(dev);
1357         struct msm_dp *dp_display = platform_get_drvdata(pdev);
1358         struct dp_display_private *dp;
1359         int sink_count = 0;
1360
1361         dp = container_of(dp_display, struct dp_display_private, dp_display);
1362
1363         mutex_lock(&dp->event_mutex);
1364
1365         drm_dbg_dp(dp->drm_dev,
1366                 "Before, type=%d core_inited=%d phy_inited=%d power_on=%d\n",
1367                 dp->dp_display.connector_type, dp->core_initialized,
1368                 dp->phy_initialized, dp_display->power_on);
1369
1370         /* start from disconnected state */
1371         dp->hpd_state = ST_DISCONNECTED;
1372
1373         /* turn on dp ctrl/phy */
1374         dp_display_host_init(dp);
1375
1376         dp_catalog_ctrl_hpd_config(dp->catalog);
1377
1378
1379         if (!dp->dp_display.is_edp)
1380                 dp_catalog_hpd_config_intr(dp->catalog,
1381                                 DP_DP_HPD_PLUG_INT_MASK |
1382                                 DP_DP_HPD_UNPLUG_INT_MASK,
1383                                 true);
1384
1385         if (dp_catalog_link_is_connected(dp->catalog)) {
1386                 /*
1387                  * set sink to normal operation mode -- D0
1388                  * before dpcd read
1389                  */
1390                 dp_display_host_phy_init(dp);
1391                 dp_link_psm_config(dp->link, &dp->panel->link_info, false);
1392                 sink_count = drm_dp_read_sink_count(dp->aux);
1393                 if (sink_count < 0)
1394                         sink_count = 0;
1395
1396                 dp_display_host_phy_exit(dp);
1397         }
1398
1399         dp->link->sink_count = sink_count;
1400         /*
1401          * can not declared display is connected unless
1402          * HDMI cable is plugged in and sink_count of
1403          * dongle become 1
1404          * also only signal audio when disconnected
1405          */
1406         if (dp->link->sink_count) {
1407                 dp->dp_display.is_connected = true;
1408         } else {
1409                 dp->dp_display.is_connected = false;
1410                 dp_display_handle_plugged_change(dp_display, false);
1411         }
1412
1413         drm_dbg_dp(dp->drm_dev,
1414                 "After, type=%d sink=%d conn=%d core_init=%d phy_init=%d power=%d\n",
1415                 dp->dp_display.connector_type, dp->link->sink_count,
1416                 dp->dp_display.is_connected, dp->core_initialized,
1417                 dp->phy_initialized, dp_display->power_on);
1418
1419         mutex_unlock(&dp->event_mutex);
1420
1421         return 0;
1422 }
1423
1424 static int dp_pm_suspend(struct device *dev)
1425 {
1426         struct platform_device *pdev = to_platform_device(dev);
1427         struct msm_dp *dp_display = platform_get_drvdata(pdev);
1428         struct dp_display_private *dp;
1429
1430         dp = container_of(dp_display, struct dp_display_private, dp_display);
1431
1432         mutex_lock(&dp->event_mutex);
1433
1434         drm_dbg_dp(dp->drm_dev,
1435                 "Before, type=%d core_inited=%d  phy_inited=%d power_on=%d\n",
1436                 dp->dp_display.connector_type, dp->core_initialized,
1437                 dp->phy_initialized, dp_display->power_on);
1438
1439         /* mainlink enabled */
1440         if (dp_power_clk_status(dp->power, DP_CTRL_PM))
1441                 dp_ctrl_off_link_stream(dp->ctrl);
1442
1443         dp_display_host_phy_exit(dp);
1444
1445         /* host_init will be called at pm_resume */
1446         dp_display_host_deinit(dp);
1447
1448         dp->hpd_state = ST_SUSPENDED;
1449
1450         drm_dbg_dp(dp->drm_dev,
1451                 "After, type=%d core_inited=%d phy_inited=%d power_on=%d\n",
1452                 dp->dp_display.connector_type, dp->core_initialized,
1453                 dp->phy_initialized, dp_display->power_on);
1454
1455         mutex_unlock(&dp->event_mutex);
1456
1457         return 0;
1458 }
1459
1460 static int dp_pm_prepare(struct device *dev)
1461 {
1462         return 0;
1463 }
1464
1465 static void dp_pm_complete(struct device *dev)
1466 {
1467
1468 }
1469
1470 static const struct dev_pm_ops dp_pm_ops = {
1471         .suspend = dp_pm_suspend,
1472         .resume =  dp_pm_resume,
1473         .prepare = dp_pm_prepare,
1474         .complete = dp_pm_complete,
1475 };
1476
1477 static struct platform_driver dp_display_driver = {
1478         .probe  = dp_display_probe,
1479         .remove = dp_display_remove,
1480         .driver = {
1481                 .name = "msm-dp-display",
1482                 .of_match_table = dp_dt_match,
1483                 .suppress_bind_attrs = true,
1484                 .pm = &dp_pm_ops,
1485         },
1486 };
1487
1488 int __init msm_dp_register(void)
1489 {
1490         int ret;
1491
1492         ret = platform_driver_register(&dp_display_driver);
1493         if (ret)
1494                 DRM_ERROR("Dp display driver register failed");
1495
1496         return ret;
1497 }
1498
1499 void __exit msm_dp_unregister(void)
1500 {
1501         platform_driver_unregister(&dp_display_driver);
1502 }
1503
1504 void msm_dp_irq_postinstall(struct msm_dp *dp_display)
1505 {
1506         struct dp_display_private *dp;
1507
1508         if (!dp_display)
1509                 return;
1510
1511         dp = container_of(dp_display, struct dp_display_private, dp_display);
1512
1513         if (!dp_display->is_edp)
1514                 dp_add_event(dp, EV_HPD_INIT_SETUP, 0, 100);
1515 }
1516
1517 bool msm_dp_wide_bus_available(const struct msm_dp *dp_display)
1518 {
1519         struct dp_display_private *dp;
1520
1521         dp = container_of(dp_display, struct dp_display_private, dp_display);
1522
1523         return dp->wide_bus_en;
1524 }
1525
1526 void msm_dp_debugfs_init(struct msm_dp *dp_display, struct drm_minor *minor)
1527 {
1528         struct dp_display_private *dp;
1529         struct device *dev;
1530         int rc;
1531
1532         dp = container_of(dp_display, struct dp_display_private, dp_display);
1533         dev = &dp->pdev->dev;
1534
1535         dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
1536                                         dp->link, dp->dp_display.connector,
1537                                         minor);
1538         if (IS_ERR(dp->debug)) {
1539                 rc = PTR_ERR(dp->debug);
1540                 DRM_ERROR("failed to initialize debug, rc = %d\n", rc);
1541                 dp->debug = NULL;
1542         }
1543 }
1544
1545 static int dp_display_get_next_bridge(struct msm_dp *dp)
1546 {
1547         int rc;
1548         struct dp_display_private *dp_priv;
1549         struct device_node *aux_bus;
1550         struct device *dev;
1551
1552         dp_priv = container_of(dp, struct dp_display_private, dp_display);
1553         dev = &dp_priv->pdev->dev;
1554         aux_bus = of_get_child_by_name(dev->of_node, "aux-bus");
1555
1556         if (aux_bus && dp->is_edp) {
1557                 dp_display_host_init(dp_priv);
1558                 dp_catalog_ctrl_hpd_config(dp_priv->catalog);
1559                 dp_display_host_phy_init(dp_priv);
1560                 enable_irq(dp_priv->irq);
1561
1562                 /*
1563                  * The code below assumes that the panel will finish probing
1564                  * by the time devm_of_dp_aux_populate_ep_devices() returns.
1565                  * This isn't a great assumption since it will fail if the
1566                  * panel driver is probed asynchronously but is the best we
1567                  * can do without a bigger driver reorganization.
1568                  */
1569                 rc = devm_of_dp_aux_populate_ep_devices(dp_priv->aux);
1570                 of_node_put(aux_bus);
1571                 if (rc)
1572                         goto error;
1573         } else if (dp->is_edp) {
1574                 DRM_ERROR("eDP aux_bus not found\n");
1575                 return -ENODEV;
1576         }
1577
1578         /*
1579          * External bridges are mandatory for eDP interfaces: one has to
1580          * provide at least an eDP panel (which gets wrapped into panel-bridge).
1581          *
1582          * For DisplayPort interfaces external bridges are optional, so
1583          * silently ignore an error if one is not present (-ENODEV).
1584          */
1585         rc = dp_parser_find_next_bridge(dp_priv->parser);
1586         if (!dp->is_edp && rc == -ENODEV)
1587                 return 0;
1588
1589         if (!rc) {
1590                 dp->next_bridge = dp_priv->parser->next_bridge;
1591                 return 0;
1592         }
1593
1594 error:
1595         if (dp->is_edp) {
1596                 disable_irq(dp_priv->irq);
1597                 dp_display_host_phy_exit(dp_priv);
1598                 dp_display_host_deinit(dp_priv);
1599         }
1600         return rc;
1601 }
1602
1603 int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
1604                         struct drm_encoder *encoder)
1605 {
1606         struct msm_drm_private *priv;
1607         struct dp_display_private *dp_priv;
1608         int ret;
1609
1610         if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
1611                 return -EINVAL;
1612
1613         priv = dev->dev_private;
1614         dp_display->drm_dev = dev;
1615
1616         dp_priv = container_of(dp_display, struct dp_display_private, dp_display);
1617
1618         ret = dp_display_request_irq(dp_display);
1619         if (ret) {
1620                 DRM_ERROR("request_irq failed, ret=%d\n", ret);
1621                 return ret;
1622         }
1623
1624         dp_display->encoder = encoder;
1625
1626         ret = dp_display_get_next_bridge(dp_display);
1627         if (ret)
1628                 return ret;
1629
1630         dp_display->bridge = dp_bridge_init(dp_display, dev, encoder);
1631         if (IS_ERR(dp_display->bridge)) {
1632                 ret = PTR_ERR(dp_display->bridge);
1633                 DRM_DEV_ERROR(dev->dev,
1634                         "failed to create dp bridge: %d\n", ret);
1635                 dp_display->bridge = NULL;
1636                 return ret;
1637         }
1638
1639         priv->bridges[priv->num_bridges++] = dp_display->bridge;
1640
1641         dp_display->connector = dp_drm_connector_init(dp_display);
1642         if (IS_ERR(dp_display->connector)) {
1643                 ret = PTR_ERR(dp_display->connector);
1644                 DRM_DEV_ERROR(dev->dev,
1645                         "failed to create dp connector: %d\n", ret);
1646                 dp_display->connector = NULL;
1647                 return ret;
1648         }
1649
1650         dp_priv->panel->connector = dp_display->connector;
1651
1652         return 0;
1653 }
1654
1655 void dp_bridge_enable(struct drm_bridge *drm_bridge)
1656 {
1657         struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1658         struct msm_dp *dp = dp_bridge->dp_display;
1659         int rc = 0;
1660         struct dp_display_private *dp_display;
1661         u32 state;
1662
1663         dp_display = container_of(dp, struct dp_display_private, dp_display);
1664         if (!dp_display->dp_mode.drm_mode.clock) {
1665                 DRM_ERROR("invalid params\n");
1666                 return;
1667         }
1668
1669         if (dp->is_edp)
1670                 dp_hpd_plug_handle(dp_display, 0);
1671
1672         mutex_lock(&dp_display->event_mutex);
1673
1674         state = dp_display->hpd_state;
1675         if (state != ST_DISPLAY_OFF && state != ST_MAINLINK_READY) {
1676                 mutex_unlock(&dp_display->event_mutex);
1677                 return;
1678         }
1679
1680         rc = dp_display_set_mode(dp, &dp_display->dp_mode);
1681         if (rc) {
1682                 DRM_ERROR("Failed to perform a mode set, rc=%d\n", rc);
1683                 mutex_unlock(&dp_display->event_mutex);
1684                 return;
1685         }
1686
1687         rc = dp_display_prepare(dp);
1688         if (rc) {
1689                 DRM_ERROR("DP display prepare failed, rc=%d\n", rc);
1690                 mutex_unlock(&dp_display->event_mutex);
1691                 return;
1692         }
1693
1694         state =  dp_display->hpd_state;
1695
1696         if (state == ST_DISPLAY_OFF)
1697                 dp_display_host_phy_init(dp_display);
1698
1699         dp_display_enable(dp_display, 0);
1700
1701         rc = dp_display_post_enable(dp);
1702         if (rc) {
1703                 DRM_ERROR("DP display post enable failed, rc=%d\n", rc);
1704                 dp_display_disable(dp_display, 0);
1705                 dp_display_unprepare(dp);
1706         }
1707
1708         /* manual kick off plug event to train link */
1709         if (state == ST_DISPLAY_OFF)
1710                 dp_add_event(dp_display, EV_IRQ_HPD_INT, 0, 0);
1711
1712         /* completed connection */
1713         dp_display->hpd_state = ST_CONNECTED;
1714
1715         drm_dbg_dp(dp->drm_dev, "type=%d Done\n", dp->connector_type);
1716         mutex_unlock(&dp_display->event_mutex);
1717 }
1718
1719 void dp_bridge_disable(struct drm_bridge *drm_bridge)
1720 {
1721         struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1722         struct msm_dp *dp = dp_bridge->dp_display;
1723         struct dp_display_private *dp_display;
1724
1725         dp_display = container_of(dp, struct dp_display_private, dp_display);
1726
1727         dp_ctrl_push_idle(dp_display->ctrl);
1728 }
1729
1730 void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
1731 {
1732         struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1733         struct msm_dp *dp = dp_bridge->dp_display;
1734         int rc = 0;
1735         u32 state;
1736         struct dp_display_private *dp_display;
1737
1738         dp_display = container_of(dp, struct dp_display_private, dp_display);
1739
1740         if (dp->is_edp)
1741                 dp_hpd_unplug_handle(dp_display, 0);
1742
1743         mutex_lock(&dp_display->event_mutex);
1744
1745         state = dp_display->hpd_state;
1746         if (state != ST_DISCONNECT_PENDING && state != ST_CONNECTED) {
1747                 mutex_unlock(&dp_display->event_mutex);
1748                 return;
1749         }
1750
1751         dp_display_disable(dp_display, 0);
1752
1753         rc = dp_display_unprepare(dp);
1754         if (rc)
1755                 DRM_ERROR("DP display unprepare failed, rc=%d\n", rc);
1756
1757         state =  dp_display->hpd_state;
1758         if (state == ST_DISCONNECT_PENDING) {
1759                 /* completed disconnection */
1760                 dp_display->hpd_state = ST_DISCONNECTED;
1761         } else {
1762                 dp_display->hpd_state = ST_DISPLAY_OFF;
1763         }
1764
1765         drm_dbg_dp(dp->drm_dev, "type=%d Done\n", dp->connector_type);
1766         mutex_unlock(&dp_display->event_mutex);
1767 }
1768
1769 void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
1770                         const struct drm_display_mode *mode,
1771                         const struct drm_display_mode *adjusted_mode)
1772 {
1773         struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1774         struct msm_dp *dp = dp_bridge->dp_display;
1775         struct dp_display_private *dp_display;
1776
1777         dp_display = container_of(dp, struct dp_display_private, dp_display);
1778
1779         memset(&dp_display->dp_mode, 0x0, sizeof(struct dp_display_mode));
1780
1781         if (dp_display_check_video_test(dp))
1782                 dp_display->dp_mode.bpp = dp_display_get_test_bpp(dp);
1783         else /* Default num_components per pixel = 3 */
1784                 dp_display->dp_mode.bpp = dp->connector->display_info.bpc * 3;
1785
1786         if (!dp_display->dp_mode.bpp)
1787                 dp_display->dp_mode.bpp = 24; /* Default bpp */
1788
1789         drm_mode_copy(&dp_display->dp_mode.drm_mode, adjusted_mode);
1790
1791         dp_display->dp_mode.v_active_low =
1792                 !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NVSYNC);
1793
1794         dp_display->dp_mode.h_active_low =
1795                 !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NHSYNC);
1796 }