Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
0004  */
0005 
0006 #include <linux/module.h>
0007 #include <linux/slab.h>
0008 #include <linux/uaccess.h>
0009 #include <linux/debugfs.h>
0010 #include <linux/component.h>
0011 #include <linux/of_irq.h>
0012 #include <linux/delay.h>
0013 #include <drm/display/drm_dp_aux_bus.h>
0014 
0015 #include "msm_drv.h"
0016 #include "msm_kms.h"
0017 #include "dp_hpd.h"
0018 #include "dp_parser.h"
0019 #include "dp_power.h"
0020 #include "dp_catalog.h"
0021 #include "dp_aux.h"
0022 #include "dp_reg.h"
0023 #include "dp_link.h"
0024 #include "dp_panel.h"
0025 #include "dp_ctrl.h"
0026 #include "dp_display.h"
0027 #include "dp_drm.h"
0028 #include "dp_audio.h"
0029 #include "dp_debug.h"
0030 
0031 #define HPD_STRING_SIZE 30
0032 
0033 enum {
0034     ISR_DISCONNECTED,
0035     ISR_CONNECT_PENDING,
0036     ISR_CONNECTED,
0037     ISR_HPD_REPLUG_COUNT,
0038     ISR_IRQ_HPD_PULSE_COUNT,
0039     ISR_HPD_LO_GLITH_COUNT,
0040 };
0041 
0042 /* event thread connection state */
0043 enum {
0044     ST_DISCONNECTED,
0045     ST_MAINLINK_READY,
0046     ST_CONNECTED,
0047     ST_DISCONNECT_PENDING,
0048     ST_DISPLAY_OFF,
0049     ST_SUSPENDED,
0050 };
0051 
0052 enum {
0053     EV_NO_EVENT,
0054     /* hpd events */
0055     EV_HPD_INIT_SETUP,
0056     EV_HPD_PLUG_INT,
0057     EV_IRQ_HPD_INT,
0058     EV_HPD_UNPLUG_INT,
0059     EV_USER_NOTIFICATION,
0060 };
0061 
0062 #define EVENT_TIMEOUT   (HZ/10) /* 100ms */
0063 #define DP_EVENT_Q_MAX  8
0064 
0065 #define DP_TIMEOUT_NONE     0
0066 
0067 #define WAIT_FOR_RESUME_TIMEOUT_JIFFIES (HZ / 2)
0068 
0069 struct dp_event {
0070     u32 event_id;
0071     u32 data;
0072     u32 delay;
0073 };
0074 
0075 struct dp_display_private {
0076     char *name;
0077     int irq;
0078 
0079     unsigned int id;
0080 
0081     /* state variables */
0082     bool core_initialized;
0083     bool phy_initialized;
0084     bool hpd_irq_on;
0085     bool audio_supported;
0086 
0087     struct drm_device *drm_dev;
0088     struct platform_device *pdev;
0089     struct dentry *root;
0090 
0091     struct dp_usbpd   *usbpd;
0092     struct dp_parser  *parser;
0093     struct dp_power   *power;
0094     struct dp_catalog *catalog;
0095     struct drm_dp_aux *aux;
0096     struct dp_link    *link;
0097     struct dp_panel   *panel;
0098     struct dp_ctrl    *ctrl;
0099     struct dp_debug   *debug;
0100 
0101     struct dp_usbpd_cb usbpd_cb;
0102     struct dp_display_mode dp_mode;
0103     struct msm_dp dp_display;
0104 
0105     /* wait for audio signaling */
0106     struct completion audio_comp;
0107 
0108     /* event related only access by event thread */
0109     struct mutex event_mutex;
0110     wait_queue_head_t event_q;
0111     u32 hpd_state;
0112     u32 event_pndx;
0113     u32 event_gndx;
0114     struct task_struct *ev_tsk;
0115     struct dp_event event_list[DP_EVENT_Q_MAX];
0116     spinlock_t event_lock;
0117 
0118     bool wide_bus_en;
0119 
0120     struct dp_audio *audio;
0121 };
0122 
0123 struct msm_dp_desc {
0124     phys_addr_t io_start;
0125     unsigned int connector_type;
0126     bool wide_bus_en;
0127 };
0128 
0129 struct msm_dp_config {
0130     const struct msm_dp_desc *descs;
0131     size_t num_descs;
0132 };
0133 
0134 static const struct msm_dp_desc sc7180_dp_descs[] = {
0135     [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
0136 };
0137 
0138 static const struct msm_dp_config sc7180_dp_cfg = {
0139     .descs = sc7180_dp_descs,
0140     .num_descs = ARRAY_SIZE(sc7180_dp_descs),
0141 };
0142 
0143 static const struct msm_dp_desc sc7280_dp_descs[] = {
0144     [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort, .wide_bus_en = true },
0145     [MSM_DP_CONTROLLER_1] = { .io_start = 0x0aea0000, .connector_type = DRM_MODE_CONNECTOR_eDP, .wide_bus_en = true },
0146 };
0147 
0148 static const struct msm_dp_config sc7280_dp_cfg = {
0149     .descs = sc7280_dp_descs,
0150     .num_descs = ARRAY_SIZE(sc7280_dp_descs),
0151 };
0152 
0153 static const struct msm_dp_desc sc8180x_dp_descs[] = {
0154     [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
0155     [MSM_DP_CONTROLLER_1] = { .io_start = 0x0ae98000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
0156     [MSM_DP_CONTROLLER_2] = { .io_start = 0x0ae9a000, .connector_type = DRM_MODE_CONNECTOR_eDP },
0157 };
0158 
0159 static const struct msm_dp_config sc8180x_dp_cfg = {
0160     .descs = sc8180x_dp_descs,
0161     .num_descs = ARRAY_SIZE(sc8180x_dp_descs),
0162 };
0163 
0164 static const struct msm_dp_desc sm8350_dp_descs[] = {
0165     [MSM_DP_CONTROLLER_0] = { .io_start = 0x0ae90000, .connector_type = DRM_MODE_CONNECTOR_DisplayPort },
0166 };
0167 
0168 static const struct msm_dp_config sm8350_dp_cfg = {
0169     .descs = sm8350_dp_descs,
0170     .num_descs = ARRAY_SIZE(sm8350_dp_descs),
0171 };
0172 
0173 static const struct of_device_id dp_dt_match[] = {
0174     { .compatible = "qcom,sc7180-dp", .data = &sc7180_dp_cfg },
0175     { .compatible = "qcom,sc7280-dp", .data = &sc7280_dp_cfg },
0176     { .compatible = "qcom,sc7280-edp", .data = &sc7280_dp_cfg },
0177     { .compatible = "qcom,sc8180x-dp", .data = &sc8180x_dp_cfg },
0178     { .compatible = "qcom,sc8180x-edp", .data = &sc8180x_dp_cfg },
0179     { .compatible = "qcom,sm8350-dp", .data = &sm8350_dp_cfg },
0180     {}
0181 };
0182 
0183 static struct dp_display_private *dev_get_dp_display_private(struct device *dev)
0184 {
0185     struct msm_dp *dp = dev_get_drvdata(dev);
0186 
0187     return container_of(dp, struct dp_display_private, dp_display);
0188 }
0189 
0190 static int dp_add_event(struct dp_display_private *dp_priv, u32 event,
0191                         u32 data, u32 delay)
0192 {
0193     unsigned long flag;
0194     struct dp_event *todo;
0195     int pndx;
0196 
0197     spin_lock_irqsave(&dp_priv->event_lock, flag);
0198     pndx = dp_priv->event_pndx + 1;
0199     pndx %= DP_EVENT_Q_MAX;
0200     if (pndx == dp_priv->event_gndx) {
0201         pr_err("event_q is full: pndx=%d gndx=%d\n",
0202             dp_priv->event_pndx, dp_priv->event_gndx);
0203         spin_unlock_irqrestore(&dp_priv->event_lock, flag);
0204         return -EPERM;
0205     }
0206     todo = &dp_priv->event_list[dp_priv->event_pndx++];
0207     dp_priv->event_pndx %= DP_EVENT_Q_MAX;
0208     todo->event_id = event;
0209     todo->data = data;
0210     todo->delay = delay;
0211     wake_up(&dp_priv->event_q);
0212     spin_unlock_irqrestore(&dp_priv->event_lock, flag);
0213 
0214     return 0;
0215 }
0216 
0217 static int dp_del_event(struct dp_display_private *dp_priv, u32 event)
0218 {
0219     unsigned long flag;
0220     struct dp_event *todo;
0221     u32 gndx;
0222 
0223     spin_lock_irqsave(&dp_priv->event_lock, flag);
0224     if (dp_priv->event_pndx == dp_priv->event_gndx) {
0225         spin_unlock_irqrestore(&dp_priv->event_lock, flag);
0226         return -ENOENT;
0227     }
0228 
0229     gndx = dp_priv->event_gndx;
0230     while (dp_priv->event_pndx != gndx) {
0231         todo = &dp_priv->event_list[gndx];
0232         if (todo->event_id == event) {
0233             todo->event_id = EV_NO_EVENT;   /* deleted */
0234             todo->delay = 0;
0235         }
0236         gndx++;
0237         gndx %= DP_EVENT_Q_MAX;
0238     }
0239     spin_unlock_irqrestore(&dp_priv->event_lock, flag);
0240 
0241     return 0;
0242 }
0243 
0244 void dp_display_signal_audio_start(struct msm_dp *dp_display)
0245 {
0246     struct dp_display_private *dp;
0247 
0248     dp = container_of(dp_display, struct dp_display_private, dp_display);
0249 
0250     reinit_completion(&dp->audio_comp);
0251 }
0252 
0253 void dp_display_signal_audio_complete(struct msm_dp *dp_display)
0254 {
0255     struct dp_display_private *dp;
0256 
0257     dp = container_of(dp_display, struct dp_display_private, dp_display);
0258 
0259     complete_all(&dp->audio_comp);
0260 }
0261 
0262 static int dp_hpd_event_thread_start(struct dp_display_private *dp_priv);
0263 
0264 static int dp_display_bind(struct device *dev, struct device *master,
0265                void *data)
0266 {
0267     int rc = 0;
0268     struct dp_display_private *dp = dev_get_dp_display_private(dev);
0269     struct msm_drm_private *priv = dev_get_drvdata(master);
0270     struct drm_device *drm = priv->dev;
0271 
0272     dp->dp_display.drm_dev = drm;
0273     priv->dp[dp->id] = &dp->dp_display;
0274 
0275     rc = dp->parser->parse(dp->parser);
0276     if (rc) {
0277         DRM_ERROR("device tree parsing failed\n");
0278         goto end;
0279     }
0280 
0281 
0282     dp->drm_dev = drm;
0283     dp->aux->drm_dev = drm;
0284     rc = dp_aux_register(dp->aux);
0285     if (rc) {
0286         DRM_ERROR("DRM DP AUX register failed\n");
0287         goto end;
0288     }
0289 
0290     rc = dp_power_client_init(dp->power);
0291     if (rc) {
0292         DRM_ERROR("Power client create failed\n");
0293         goto end;
0294     }
0295 
0296     rc = dp_register_audio_driver(dev, dp->audio);
0297     if (rc) {
0298         DRM_ERROR("Audio registration Dp failed\n");
0299         goto end;
0300     }
0301 
0302     rc = dp_hpd_event_thread_start(dp);
0303     if (rc) {
0304         DRM_ERROR("Event thread create failed\n");
0305         goto end;
0306     }
0307 
0308     return 0;
0309 end:
0310     return rc;
0311 }
0312 
0313 static void dp_display_unbind(struct device *dev, struct device *master,
0314                   void *data)
0315 {
0316     struct dp_display_private *dp = dev_get_dp_display_private(dev);
0317     struct msm_drm_private *priv = dev_get_drvdata(master);
0318 
0319     /* disable all HPD interrupts */
0320     if (dp->core_initialized)
0321         dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_INT_MASK, false);
0322 
0323     kthread_stop(dp->ev_tsk);
0324 
0325     dp_power_client_deinit(dp->power);
0326     dp_aux_unregister(dp->aux);
0327     dp->drm_dev = NULL;
0328     dp->aux->drm_dev = NULL;
0329     priv->dp[dp->id] = NULL;
0330 }
0331 
0332 static const struct component_ops dp_display_comp_ops = {
0333     .bind = dp_display_bind,
0334     .unbind = dp_display_unbind,
0335 };
0336 
0337 static bool dp_display_is_ds_bridge(struct dp_panel *panel)
0338 {
0339     return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
0340         DP_DWN_STRM_PORT_PRESENT);
0341 }
0342 
0343 static bool dp_display_is_sink_count_zero(struct dp_display_private *dp)
0344 {
0345     drm_dbg_dp(dp->drm_dev, "present=%#x sink_count=%d\n",
0346             dp->panel->dpcd[DP_DOWNSTREAMPORT_PRESENT],
0347         dp->link->sink_count);
0348     return dp_display_is_ds_bridge(dp->panel) &&
0349         (dp->link->sink_count == 0);
0350 }
0351 
0352 static void dp_display_send_hpd_event(struct msm_dp *dp_display)
0353 {
0354     struct dp_display_private *dp;
0355     struct drm_connector *connector;
0356 
0357     dp = container_of(dp_display, struct dp_display_private, dp_display);
0358 
0359     connector = dp->dp_display.connector;
0360     drm_helper_hpd_irq_event(connector->dev);
0361 }
0362 
0363 
0364 static int dp_display_send_hpd_notification(struct dp_display_private *dp,
0365                         bool hpd)
0366 {
0367     if ((hpd && dp->dp_display.is_connected) ||
0368             (!hpd && !dp->dp_display.is_connected)) {
0369         drm_dbg_dp(dp->drm_dev, "HPD already %s\n",
0370                 (hpd ? "on" : "off"));
0371         return 0;
0372     }
0373 
0374     /* reset video pattern flag on disconnect */
0375     if (!hpd)
0376         dp->panel->video_test = false;
0377 
0378     dp->dp_display.is_connected = hpd;
0379 
0380     drm_dbg_dp(dp->drm_dev, "type=%d hpd=%d\n",
0381             dp->dp_display.connector_type, hpd);
0382     dp_display_send_hpd_event(&dp->dp_display);
0383 
0384     return 0;
0385 }
0386 
0387 static int dp_display_process_hpd_high(struct dp_display_private *dp)
0388 {
0389     int rc = 0;
0390     struct edid *edid;
0391 
0392     dp->panel->max_dp_lanes = dp->parser->max_dp_lanes;
0393 
0394     rc = dp_panel_read_sink_caps(dp->panel, dp->dp_display.connector);
0395     if (rc)
0396         goto end;
0397 
0398     dp_link_process_request(dp->link);
0399 
0400     edid = dp->panel->edid;
0401 
0402     dp->audio_supported = drm_detect_monitor_audio(edid);
0403     dp_panel_handle_sink_request(dp->panel);
0404 
0405     dp->dp_display.max_dp_lanes = dp->parser->max_dp_lanes;
0406 
0407     /*
0408      * set sink to normal operation mode -- D0
0409      * before dpcd read
0410      */
0411     dp_link_psm_config(dp->link, &dp->panel->link_info, false);
0412 
0413     dp_link_reset_phy_params_vx_px(dp->link);
0414     rc = dp_ctrl_on_link(dp->ctrl);
0415     if (rc) {
0416         DRM_ERROR("failed to complete DP link training\n");
0417         goto end;
0418     }
0419 
0420     dp_add_event(dp, EV_USER_NOTIFICATION, true, 0);
0421 
0422 end:
0423     return rc;
0424 }
0425 
0426 static void dp_display_host_phy_init(struct dp_display_private *dp)
0427 {
0428     drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
0429         dp->dp_display.connector_type, dp->core_initialized,
0430         dp->phy_initialized);
0431 
0432     if (!dp->phy_initialized) {
0433         dp_ctrl_phy_init(dp->ctrl);
0434         dp->phy_initialized = true;
0435     }
0436 }
0437 
0438 static void dp_display_host_phy_exit(struct dp_display_private *dp)
0439 {
0440     drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
0441         dp->dp_display.connector_type, dp->core_initialized,
0442         dp->phy_initialized);
0443 
0444     if (dp->phy_initialized) {
0445         dp_ctrl_phy_exit(dp->ctrl);
0446         dp->phy_initialized = false;
0447     }
0448 }
0449 
0450 static void dp_display_host_init(struct dp_display_private *dp)
0451 {
0452     drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
0453         dp->dp_display.connector_type, dp->core_initialized,
0454         dp->phy_initialized);
0455 
0456     dp_power_init(dp->power, false);
0457     dp_ctrl_reset_irq_ctrl(dp->ctrl, true);
0458     dp_aux_init(dp->aux);
0459     dp->core_initialized = true;
0460 }
0461 
0462 static void dp_display_host_deinit(struct dp_display_private *dp)
0463 {
0464     drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n",
0465         dp->dp_display.connector_type, dp->core_initialized,
0466         dp->phy_initialized);
0467 
0468     dp_ctrl_reset_irq_ctrl(dp->ctrl, false);
0469     dp_aux_deinit(dp->aux);
0470     dp_power_deinit(dp->power);
0471     dp->core_initialized = false;
0472 }
0473 
0474 static int dp_display_usbpd_configure_cb(struct device *dev)
0475 {
0476     struct dp_display_private *dp = dev_get_dp_display_private(dev);
0477 
0478     dp_display_host_phy_init(dp);
0479 
0480     return dp_display_process_hpd_high(dp);
0481 }
0482 
0483 static int dp_display_usbpd_disconnect_cb(struct device *dev)
0484 {
0485     return 0;
0486 }
0487 
0488 static int dp_display_notify_disconnect(struct device *dev)
0489 {
0490     struct dp_display_private *dp = dev_get_dp_display_private(dev);
0491 
0492     dp_add_event(dp, EV_USER_NOTIFICATION, false, 0);
0493 
0494     return 0;
0495 }
0496 
0497 static void dp_display_handle_video_request(struct dp_display_private *dp)
0498 {
0499     if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
0500         dp->panel->video_test = true;
0501         dp_link_send_test_response(dp->link);
0502     }
0503 }
0504 
0505 static int dp_display_handle_port_ststus_changed(struct dp_display_private *dp)
0506 {
0507     int rc = 0;
0508 
0509     if (dp_display_is_sink_count_zero(dp)) {
0510         drm_dbg_dp(dp->drm_dev, "sink count is zero, nothing to do\n");
0511         if (dp->hpd_state != ST_DISCONNECTED) {
0512             dp->hpd_state = ST_DISCONNECT_PENDING;
0513             dp_add_event(dp, EV_USER_NOTIFICATION, false, 0);
0514         }
0515     } else {
0516         if (dp->hpd_state == ST_DISCONNECTED) {
0517             dp->hpd_state = ST_MAINLINK_READY;
0518             rc = dp_display_process_hpd_high(dp);
0519             if (rc)
0520                 dp->hpd_state = ST_DISCONNECTED;
0521         }
0522     }
0523 
0524     return rc;
0525 }
0526 
0527 static int dp_display_handle_irq_hpd(struct dp_display_private *dp)
0528 {
0529     u32 sink_request = dp->link->sink_request;
0530 
0531     drm_dbg_dp(dp->drm_dev, "%d\n", sink_request);
0532     if (dp->hpd_state == ST_DISCONNECTED) {
0533         if (sink_request & DP_LINK_STATUS_UPDATED) {
0534             drm_dbg_dp(dp->drm_dev, "Disconnected sink_request: %d\n",
0535                             sink_request);
0536             DRM_ERROR("Disconnected, no DP_LINK_STATUS_UPDATED\n");
0537             return -EINVAL;
0538         }
0539     }
0540 
0541     dp_ctrl_handle_sink_request(dp->ctrl);
0542 
0543     if (sink_request & DP_TEST_LINK_VIDEO_PATTERN)
0544         dp_display_handle_video_request(dp);
0545 
0546     return 0;
0547 }
0548 
0549 static int dp_display_usbpd_attention_cb(struct device *dev)
0550 {
0551     int rc = 0;
0552     u32 sink_request;
0553     struct dp_display_private *dp = dev_get_dp_display_private(dev);
0554 
0555     /* check for any test request issued by sink */
0556     rc = dp_link_process_request(dp->link);
0557     if (!rc) {
0558         sink_request = dp->link->sink_request;
0559         drm_dbg_dp(dp->drm_dev, "hpd_state=%d sink_request=%d\n",
0560                     dp->hpd_state, sink_request);
0561         if (sink_request & DS_PORT_STATUS_CHANGED)
0562             rc = dp_display_handle_port_ststus_changed(dp);
0563         else
0564             rc = dp_display_handle_irq_hpd(dp);
0565     }
0566 
0567     return rc;
0568 }
0569 
0570 static int dp_hpd_plug_handle(struct dp_display_private *dp, u32 data)
0571 {
0572     struct dp_usbpd *hpd = dp->usbpd;
0573     u32 state;
0574     int ret;
0575 
0576     if (!hpd)
0577         return 0;
0578 
0579     mutex_lock(&dp->event_mutex);
0580 
0581     state =  dp->hpd_state;
0582     drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n",
0583             dp->dp_display.connector_type, state);
0584 
0585     if (state == ST_DISPLAY_OFF || state == ST_SUSPENDED) {
0586         mutex_unlock(&dp->event_mutex);
0587         return 0;
0588     }
0589 
0590     if (state == ST_MAINLINK_READY || state == ST_CONNECTED) {
0591         mutex_unlock(&dp->event_mutex);
0592         return 0;
0593     }
0594 
0595     if (state == ST_DISCONNECT_PENDING) {
0596         /* wait until ST_DISCONNECTED */
0597         dp_add_event(dp, EV_HPD_PLUG_INT, 0, 1); /* delay = 1 */
0598         mutex_unlock(&dp->event_mutex);
0599         return 0;
0600     }
0601 
0602     ret = dp_display_usbpd_configure_cb(&dp->pdev->dev);
0603     if (ret) {  /* link train failed */
0604         dp->hpd_state = ST_DISCONNECTED;
0605     } else {
0606         dp->hpd_state = ST_MAINLINK_READY;
0607     }
0608 
0609     /* enable HDP irq_hpd/replug interrupt */
0610     dp_catalog_hpd_config_intr(dp->catalog,
0611         DP_DP_IRQ_HPD_INT_MASK | DP_DP_HPD_REPLUG_INT_MASK, true);
0612 
0613     drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n",
0614             dp->dp_display.connector_type, state);
0615     mutex_unlock(&dp->event_mutex);
0616 
0617     /* uevent will complete connection part */
0618     return 0;
0619 };
0620 
0621 static void dp_display_handle_plugged_change(struct msm_dp *dp_display,
0622         bool plugged)
0623 {
0624     struct dp_display_private *dp;
0625 
0626     dp = container_of(dp_display,
0627             struct dp_display_private, dp_display);
0628 
0629     /* notify audio subsystem only if sink supports audio */
0630     if (dp_display->plugged_cb && dp_display->codec_dev &&
0631             dp->audio_supported)
0632         dp_display->plugged_cb(dp_display->codec_dev, plugged);
0633 }
0634 
0635 static int dp_hpd_unplug_handle(struct dp_display_private *dp, u32 data)
0636 {
0637     struct dp_usbpd *hpd = dp->usbpd;
0638     u32 state;
0639 
0640     if (!hpd)
0641         return 0;
0642 
0643     mutex_lock(&dp->event_mutex);
0644 
0645     state = dp->hpd_state;
0646 
0647     drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n",
0648             dp->dp_display.connector_type, state);
0649 
0650     /* disable irq_hpd/replug interrupts */
0651     dp_catalog_hpd_config_intr(dp->catalog,
0652         DP_DP_IRQ_HPD_INT_MASK | DP_DP_HPD_REPLUG_INT_MASK, false);
0653 
0654     /* unplugged, no more irq_hpd handle */
0655     dp_del_event(dp, EV_IRQ_HPD_INT);
0656 
0657     if (state == ST_DISCONNECTED) {
0658         /* triggered by irq_hdp with sink_count = 0 */
0659         if (dp->link->sink_count == 0) {
0660             dp_display_host_phy_exit(dp);
0661         }
0662         dp_display_notify_disconnect(&dp->pdev->dev);
0663         mutex_unlock(&dp->event_mutex);
0664         return 0;
0665     } else if (state == ST_DISCONNECT_PENDING) {
0666         mutex_unlock(&dp->event_mutex);
0667         return 0;
0668     } else if (state == ST_MAINLINK_READY) {
0669         dp_ctrl_off_link(dp->ctrl);
0670         dp_display_host_phy_exit(dp);
0671         dp->hpd_state = ST_DISCONNECTED;
0672         dp_display_notify_disconnect(&dp->pdev->dev);
0673         mutex_unlock(&dp->event_mutex);
0674         return 0;
0675     }
0676 
0677     /* disable HPD plug interrupts */
0678     dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK, false);
0679 
0680     /*
0681      * We don't need separate work for disconnect as
0682      * connect/attention interrupts are disabled
0683      */
0684     dp_display_notify_disconnect(&dp->pdev->dev);
0685 
0686     if (state == ST_DISPLAY_OFF) {
0687         dp->hpd_state = ST_DISCONNECTED;
0688     } else {
0689         dp->hpd_state = ST_DISCONNECT_PENDING;
0690     }
0691 
0692     /* signal the disconnect event early to ensure proper teardown */
0693     dp_display_handle_plugged_change(&dp->dp_display, false);
0694 
0695     /* enable HDP plug interrupt to prepare for next plugin */
0696     if (!dp->dp_display.is_edp)
0697         dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK, true);
0698 
0699     drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n",
0700             dp->dp_display.connector_type, state);
0701 
0702     /* uevent will complete disconnection part */
0703     mutex_unlock(&dp->event_mutex);
0704     return 0;
0705 }
0706 
0707 static int dp_irq_hpd_handle(struct dp_display_private *dp, u32 data)
0708 {
0709     u32 state;
0710 
0711     mutex_lock(&dp->event_mutex);
0712 
0713     /* irq_hpd can happen at either connected or disconnected state */
0714     state =  dp->hpd_state;
0715     drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n",
0716             dp->dp_display.connector_type, state);
0717 
0718     if (state == ST_DISPLAY_OFF || state == ST_SUSPENDED) {
0719         mutex_unlock(&dp->event_mutex);
0720         return 0;
0721     }
0722 
0723     if (state == ST_MAINLINK_READY || state == ST_DISCONNECT_PENDING) {
0724         /* wait until ST_CONNECTED */
0725         dp_add_event(dp, EV_IRQ_HPD_INT, 0, 1); /* delay = 1 */
0726         mutex_unlock(&dp->event_mutex);
0727         return 0;
0728     }
0729 
0730     dp_display_usbpd_attention_cb(&dp->pdev->dev);
0731 
0732     drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n",
0733             dp->dp_display.connector_type, state);
0734 
0735     mutex_unlock(&dp->event_mutex);
0736 
0737     return 0;
0738 }
0739 
0740 static void dp_display_deinit_sub_modules(struct dp_display_private *dp)
0741 {
0742     dp_debug_put(dp->debug);
0743     dp_audio_put(dp->audio);
0744     dp_panel_put(dp->panel);
0745     dp_aux_put(dp->aux);
0746 }
0747 
0748 static int dp_init_sub_modules(struct dp_display_private *dp)
0749 {
0750     int rc = 0;
0751     struct device *dev = &dp->pdev->dev;
0752     struct dp_usbpd_cb *cb = &dp->usbpd_cb;
0753     struct dp_panel_in panel_in = {
0754         .dev = dev,
0755     };
0756 
0757     /* Callback APIs used for cable status change event */
0758     cb->configure  = dp_display_usbpd_configure_cb;
0759     cb->disconnect = dp_display_usbpd_disconnect_cb;
0760     cb->attention  = dp_display_usbpd_attention_cb;
0761 
0762     dp->usbpd = dp_hpd_get(dev, cb);
0763     if (IS_ERR(dp->usbpd)) {
0764         rc = PTR_ERR(dp->usbpd);
0765         DRM_ERROR("failed to initialize hpd, rc = %d\n", rc);
0766         dp->usbpd = NULL;
0767         goto error;
0768     }
0769 
0770     dp->parser = dp_parser_get(dp->pdev);
0771     if (IS_ERR(dp->parser)) {
0772         rc = PTR_ERR(dp->parser);
0773         DRM_ERROR("failed to initialize parser, rc = %d\n", rc);
0774         dp->parser = NULL;
0775         goto error;
0776     }
0777 
0778     dp->catalog = dp_catalog_get(dev, &dp->parser->io);
0779     if (IS_ERR(dp->catalog)) {
0780         rc = PTR_ERR(dp->catalog);
0781         DRM_ERROR("failed to initialize catalog, rc = %d\n", rc);
0782         dp->catalog = NULL;
0783         goto error;
0784     }
0785 
0786     dp->power = dp_power_get(dev, dp->parser);
0787     if (IS_ERR(dp->power)) {
0788         rc = PTR_ERR(dp->power);
0789         DRM_ERROR("failed to initialize power, rc = %d\n", rc);
0790         dp->power = NULL;
0791         goto error;
0792     }
0793 
0794     dp->aux = dp_aux_get(dev, dp->catalog, dp->dp_display.is_edp);
0795     if (IS_ERR(dp->aux)) {
0796         rc = PTR_ERR(dp->aux);
0797         DRM_ERROR("failed to initialize aux, rc = %d\n", rc);
0798         dp->aux = NULL;
0799         goto error;
0800     }
0801 
0802     dp->link = dp_link_get(dev, dp->aux);
0803     if (IS_ERR(dp->link)) {
0804         rc = PTR_ERR(dp->link);
0805         DRM_ERROR("failed to initialize link, rc = %d\n", rc);
0806         dp->link = NULL;
0807         goto error_link;
0808     }
0809 
0810     panel_in.aux = dp->aux;
0811     panel_in.catalog = dp->catalog;
0812     panel_in.link = dp->link;
0813 
0814     dp->panel = dp_panel_get(&panel_in);
0815     if (IS_ERR(dp->panel)) {
0816         rc = PTR_ERR(dp->panel);
0817         DRM_ERROR("failed to initialize panel, rc = %d\n", rc);
0818         dp->panel = NULL;
0819         goto error_link;
0820     }
0821 
0822     dp->ctrl = dp_ctrl_get(dev, dp->link, dp->panel, dp->aux,
0823                    dp->power, dp->catalog, dp->parser);
0824     if (IS_ERR(dp->ctrl)) {
0825         rc = PTR_ERR(dp->ctrl);
0826         DRM_ERROR("failed to initialize ctrl, rc = %d\n", rc);
0827         dp->ctrl = NULL;
0828         goto error_ctrl;
0829     }
0830 
0831     dp->audio = dp_audio_get(dp->pdev, dp->panel, dp->catalog);
0832     if (IS_ERR(dp->audio)) {
0833         rc = PTR_ERR(dp->audio);
0834         pr_err("failed to initialize audio, rc = %d\n", rc);
0835         dp->audio = NULL;
0836         goto error_ctrl;
0837     }
0838 
0839     /* populate wide_bus_en to differernt layers */
0840     dp->ctrl->wide_bus_en = dp->wide_bus_en;
0841     dp->catalog->wide_bus_en = dp->wide_bus_en;
0842 
0843     return rc;
0844 
0845 error_ctrl:
0846     dp_panel_put(dp->panel);
0847 error_link:
0848     dp_aux_put(dp->aux);
0849 error:
0850     return rc;
0851 }
0852 
0853 static int dp_display_set_mode(struct msm_dp *dp_display,
0854                    struct dp_display_mode *mode)
0855 {
0856     struct dp_display_private *dp;
0857 
0858     dp = container_of(dp_display, struct dp_display_private, dp_display);
0859 
0860     dp->panel->dp_mode.drm_mode = mode->drm_mode;
0861     dp->panel->dp_mode.bpp = mode->bpp;
0862     dp->panel->dp_mode.capabilities = mode->capabilities;
0863     dp_panel_init_panel_info(dp->panel);
0864     return 0;
0865 }
0866 
0867 static int dp_display_enable(struct dp_display_private *dp, bool force_link_train)
0868 {
0869     int rc = 0;
0870     struct msm_dp *dp_display = &dp->dp_display;
0871 
0872     drm_dbg_dp(dp->drm_dev, "sink_count=%d\n", dp->link->sink_count);
0873     if (dp_display->power_on) {
0874         drm_dbg_dp(dp->drm_dev, "Link already setup, return\n");
0875         return 0;
0876     }
0877 
0878     rc = dp_ctrl_on_stream(dp->ctrl, force_link_train);
0879     if (!rc)
0880         dp_display->power_on = true;
0881 
0882     return rc;
0883 }
0884 
0885 static int dp_display_post_enable(struct msm_dp *dp_display)
0886 {
0887     struct dp_display_private *dp;
0888     u32 rate;
0889 
0890     dp = container_of(dp_display, struct dp_display_private, dp_display);
0891 
0892     rate = dp->link->link_params.rate;
0893 
0894     if (dp->audio_supported) {
0895         dp->audio->bw_code = drm_dp_link_rate_to_bw_code(rate);
0896         dp->audio->lane_count = dp->link->link_params.num_lanes;
0897     }
0898 
0899     /* signal the connect event late to synchronize video and display */
0900     dp_display_handle_plugged_change(dp_display, true);
0901     return 0;
0902 }
0903 
0904 static int dp_display_disable(struct dp_display_private *dp)
0905 {
0906     struct msm_dp *dp_display = &dp->dp_display;
0907 
0908     if (!dp_display->power_on)
0909         return 0;
0910 
0911     /* wait only if audio was enabled */
0912     if (dp_display->audio_enabled) {
0913         /* signal the disconnect event */
0914         dp_display_handle_plugged_change(dp_display, false);
0915         if (!wait_for_completion_timeout(&dp->audio_comp,
0916                 HZ * 5))
0917             DRM_ERROR("audio comp timeout\n");
0918     }
0919 
0920     dp_display->audio_enabled = false;
0921 
0922     if (dp->link->sink_count == 0) {
0923         /*
0924          * irq_hpd with sink_count = 0
0925          * hdmi unplugged out of dongle
0926          */
0927         dp_ctrl_off_link_stream(dp->ctrl);
0928     } else {
0929         /*
0930          * unplugged interrupt
0931          * dongle unplugged out of DUT
0932          */
0933         dp_ctrl_off(dp->ctrl);
0934         dp_display_host_phy_exit(dp);
0935     }
0936 
0937     dp_display->power_on = false;
0938 
0939     drm_dbg_dp(dp->drm_dev, "sink count: %d\n", dp->link->sink_count);
0940     return 0;
0941 }
0942 
0943 int dp_display_set_plugged_cb(struct msm_dp *dp_display,
0944         hdmi_codec_plugged_cb fn, struct device *codec_dev)
0945 {
0946     bool plugged;
0947 
0948     dp_display->plugged_cb = fn;
0949     dp_display->codec_dev = codec_dev;
0950     plugged = dp_display->is_connected;
0951     dp_display_handle_plugged_change(dp_display, plugged);
0952 
0953     return 0;
0954 }
0955 
0956 /**
0957  * dp_bridge_mode_valid - callback to determine if specified mode is valid
0958  * @bridge: Pointer to drm bridge structure
0959  * @info: display info
0960  * @mode: Pointer to drm mode structure
0961  * Returns: Validity status for specified mode
0962  */
0963 enum drm_mode_status dp_bridge_mode_valid(struct drm_bridge *bridge,
0964                       const struct drm_display_info *info,
0965                       const struct drm_display_mode *mode)
0966 {
0967     const u32 num_components = 3, default_bpp = 24;
0968     struct dp_display_private *dp_display;
0969     struct dp_link_info *link_info;
0970     u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
0971     struct msm_dp *dp;
0972     int mode_pclk_khz = mode->clock;
0973 
0974     dp = to_dp_bridge(bridge)->dp_display;
0975 
0976     if (!dp || !mode_pclk_khz || !dp->connector) {
0977         DRM_ERROR("invalid params\n");
0978         return -EINVAL;
0979     }
0980 
0981     /*
0982      * The eDP controller currently does not have a reliable way of
0983      * enabling panel power to read sink capabilities. So, we rely
0984      * on the panel driver to populate only supported modes for now.
0985      */
0986     if (dp->is_edp)
0987         return MODE_OK;
0988 
0989     if (mode->clock > DP_MAX_PIXEL_CLK_KHZ)
0990         return MODE_CLOCK_HIGH;
0991 
0992     dp_display = container_of(dp, struct dp_display_private, dp_display);
0993     link_info = &dp_display->panel->link_info;
0994 
0995     mode_bpp = dp->connector->display_info.bpc * num_components;
0996     if (!mode_bpp)
0997         mode_bpp = default_bpp;
0998 
0999     mode_bpp = dp_panel_get_mode_bpp(dp_display->panel,
1000             mode_bpp, mode_pclk_khz);
1001 
1002     mode_rate_khz = mode_pclk_khz * mode_bpp;
1003     supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
1004 
1005     if (mode_rate_khz > supported_rate_khz)
1006         return MODE_BAD;
1007 
1008     return MODE_OK;
1009 }
1010 
1011 int dp_display_get_modes(struct msm_dp *dp)
1012 {
1013     struct dp_display_private *dp_display;
1014 
1015     if (!dp) {
1016         DRM_ERROR("invalid params\n");
1017         return 0;
1018     }
1019 
1020     dp_display = container_of(dp, struct dp_display_private, dp_display);
1021 
1022     return dp_panel_get_modes(dp_display->panel,
1023         dp->connector);
1024 }
1025 
1026 bool dp_display_check_video_test(struct msm_dp *dp)
1027 {
1028     struct dp_display_private *dp_display;
1029 
1030     dp_display = container_of(dp, struct dp_display_private, dp_display);
1031 
1032     return dp_display->panel->video_test;
1033 }
1034 
1035 int dp_display_get_test_bpp(struct msm_dp *dp)
1036 {
1037     struct dp_display_private *dp_display;
1038 
1039     if (!dp) {
1040         DRM_ERROR("invalid params\n");
1041         return 0;
1042     }
1043 
1044     dp_display = container_of(dp, struct dp_display_private, dp_display);
1045 
1046     return dp_link_bit_depth_to_bpp(
1047         dp_display->link->test_video.test_bit_depth);
1048 }
1049 
1050 void msm_dp_snapshot(struct msm_disp_state *disp_state, struct msm_dp *dp)
1051 {
1052     struct dp_display_private *dp_display;
1053 
1054     dp_display = container_of(dp, struct dp_display_private, dp_display);
1055 
1056     /*
1057      * if we are reading registers we need the link clocks to be on
1058      * however till DP cable is connected this will not happen as we
1059      * do not know the resolution to power up with. Hence check the
1060      * power_on status before dumping DP registers to avoid crash due
1061      * to unclocked access
1062      */
1063     mutex_lock(&dp_display->event_mutex);
1064 
1065     if (!dp->power_on) {
1066         mutex_unlock(&dp_display->event_mutex);
1067         return;
1068     }
1069 
1070     dp_catalog_snapshot(dp_display->catalog, disp_state);
1071 
1072     mutex_unlock(&dp_display->event_mutex);
1073 }
1074 
1075 static void dp_display_config_hpd(struct dp_display_private *dp)
1076 {
1077 
1078     dp_display_host_init(dp);
1079     dp_catalog_ctrl_hpd_config(dp->catalog);
1080 
1081     /* Enable plug and unplug interrupts only for external DisplayPort */
1082     if (!dp->dp_display.is_edp)
1083         dp_catalog_hpd_config_intr(dp->catalog,
1084                 DP_DP_HPD_PLUG_INT_MASK |
1085                 DP_DP_HPD_UNPLUG_INT_MASK,
1086                 true);
1087 
1088     /* Enable interrupt first time
1089      * we are leaving dp clocks on during disconnect
1090      * and never disable interrupt
1091      */
1092     enable_irq(dp->irq);
1093 }
1094 
1095 static int hpd_event_thread(void *data)
1096 {
1097     struct dp_display_private *dp_priv;
1098     unsigned long flag;
1099     struct dp_event *todo;
1100     int timeout_mode = 0;
1101 
1102     dp_priv = (struct dp_display_private *)data;
1103 
1104     while (1) {
1105         if (timeout_mode) {
1106             wait_event_timeout(dp_priv->event_q,
1107                 (dp_priv->event_pndx == dp_priv->event_gndx) ||
1108                     kthread_should_stop(), EVENT_TIMEOUT);
1109         } else {
1110             wait_event_interruptible(dp_priv->event_q,
1111                 (dp_priv->event_pndx != dp_priv->event_gndx) ||
1112                     kthread_should_stop());
1113         }
1114 
1115         if (kthread_should_stop())
1116             break;
1117 
1118         spin_lock_irqsave(&dp_priv->event_lock, flag);
1119         todo = &dp_priv->event_list[dp_priv->event_gndx];
1120         if (todo->delay) {
1121             struct dp_event *todo_next;
1122 
1123             dp_priv->event_gndx++;
1124             dp_priv->event_gndx %= DP_EVENT_Q_MAX;
1125 
1126             /* re enter delay event into q */
1127             todo_next = &dp_priv->event_list[dp_priv->event_pndx++];
1128             dp_priv->event_pndx %= DP_EVENT_Q_MAX;
1129             todo_next->event_id = todo->event_id;
1130             todo_next->data = todo->data;
1131             todo_next->delay = todo->delay - 1;
1132 
1133             /* clean up older event */
1134             todo->event_id = EV_NO_EVENT;
1135             todo->delay = 0;
1136 
1137             /* switch to timeout mode */
1138             timeout_mode = 1;
1139             spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1140             continue;
1141         }
1142 
1143         /* timeout with no events in q */
1144         if (dp_priv->event_pndx == dp_priv->event_gndx) {
1145             spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1146             continue;
1147         }
1148 
1149         dp_priv->event_gndx++;
1150         dp_priv->event_gndx %= DP_EVENT_Q_MAX;
1151         timeout_mode = 0;
1152         spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1153 
1154         switch (todo->event_id) {
1155         case EV_HPD_INIT_SETUP:
1156             dp_display_config_hpd(dp_priv);
1157             break;
1158         case EV_HPD_PLUG_INT:
1159             dp_hpd_plug_handle(dp_priv, todo->data);
1160             break;
1161         case EV_HPD_UNPLUG_INT:
1162             dp_hpd_unplug_handle(dp_priv, todo->data);
1163             break;
1164         case EV_IRQ_HPD_INT:
1165             dp_irq_hpd_handle(dp_priv, todo->data);
1166             break;
1167         case EV_USER_NOTIFICATION:
1168             dp_display_send_hpd_notification(dp_priv,
1169                         todo->data);
1170             break;
1171         default:
1172             break;
1173         }
1174     }
1175 
1176     return 0;
1177 }
1178 
1179 static int dp_hpd_event_thread_start(struct dp_display_private *dp_priv)
1180 {
1181     /* set event q to empty */
1182     dp_priv->event_gndx = 0;
1183     dp_priv->event_pndx = 0;
1184 
1185     dp_priv->ev_tsk = kthread_run(hpd_event_thread, dp_priv, "dp_hpd_handler");
1186     if (IS_ERR(dp_priv->ev_tsk))
1187         return PTR_ERR(dp_priv->ev_tsk);
1188 
1189     return 0;
1190 }
1191 
1192 static irqreturn_t dp_display_irq_handler(int irq, void *dev_id)
1193 {
1194     struct dp_display_private *dp = dev_id;
1195     irqreturn_t ret = IRQ_HANDLED;
1196     u32 hpd_isr_status;
1197 
1198     if (!dp) {
1199         DRM_ERROR("invalid data\n");
1200         return IRQ_NONE;
1201     }
1202 
1203     hpd_isr_status = dp_catalog_hpd_get_intr_status(dp->catalog);
1204 
1205     if (hpd_isr_status & 0x0F) {
1206         drm_dbg_dp(dp->drm_dev, "type=%d isr=0x%x\n",
1207             dp->dp_display.connector_type, hpd_isr_status);
1208         /* hpd related interrupts */
1209         if (hpd_isr_status & DP_DP_HPD_PLUG_INT_MASK)
1210             dp_add_event(dp, EV_HPD_PLUG_INT, 0, 0);
1211 
1212         if (hpd_isr_status & DP_DP_IRQ_HPD_INT_MASK) {
1213             dp_add_event(dp, EV_IRQ_HPD_INT, 0, 0);
1214         }
1215 
1216         if (hpd_isr_status & DP_DP_HPD_REPLUG_INT_MASK) {
1217             dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0);
1218             dp_add_event(dp, EV_HPD_PLUG_INT, 0, 3);
1219         }
1220 
1221         if (hpd_isr_status & DP_DP_HPD_UNPLUG_INT_MASK)
1222             dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0);
1223     }
1224 
1225     /* DP controller isr */
1226     dp_ctrl_isr(dp->ctrl);
1227 
1228     /* DP aux isr */
1229     dp_aux_isr(dp->aux);
1230 
1231     return ret;
1232 }
1233 
1234 int dp_display_request_irq(struct msm_dp *dp_display)
1235 {
1236     int rc = 0;
1237     struct dp_display_private *dp;
1238 
1239     if (!dp_display) {
1240         DRM_ERROR("invalid input\n");
1241         return -EINVAL;
1242     }
1243 
1244     dp = container_of(dp_display, struct dp_display_private, dp_display);
1245 
1246     dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
1247     if (!dp->irq) {
1248         DRM_ERROR("failed to get irq\n");
1249         return -EINVAL;
1250     }
1251 
1252     rc = devm_request_irq(&dp->pdev->dev, dp->irq,
1253             dp_display_irq_handler,
1254             IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
1255     if (rc < 0) {
1256         DRM_ERROR("failed to request IRQ%u: %d\n",
1257                 dp->irq, rc);
1258         return rc;
1259     }
1260     disable_irq(dp->irq);
1261 
1262     return 0;
1263 }
1264 
1265 static const struct msm_dp_desc *dp_display_get_desc(struct platform_device *pdev,
1266                              unsigned int *id)
1267 {
1268     const struct msm_dp_config *cfg = of_device_get_match_data(&pdev->dev);
1269     struct resource *res;
1270     int i;
1271 
1272     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1273     if (!res)
1274         return NULL;
1275 
1276     for (i = 0; i < cfg->num_descs; i++) {
1277         if (cfg->descs[i].io_start == res->start) {
1278             *id = i;
1279             return &cfg->descs[i];
1280         }
1281     }
1282 
1283     dev_err(&pdev->dev, "unknown displayport instance\n");
1284     return NULL;
1285 }
1286 
1287 static int dp_display_probe(struct platform_device *pdev)
1288 {
1289     int rc = 0;
1290     struct dp_display_private *dp;
1291     const struct msm_dp_desc *desc;
1292 
1293     if (!pdev || !pdev->dev.of_node) {
1294         DRM_ERROR("pdev not found\n");
1295         return -ENODEV;
1296     }
1297 
1298     dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
1299     if (!dp)
1300         return -ENOMEM;
1301 
1302     desc = dp_display_get_desc(pdev, &dp->id);
1303     if (!desc)
1304         return -EINVAL;
1305 
1306     dp->pdev = pdev;
1307     dp->name = "drm_dp";
1308     dp->dp_display.connector_type = desc->connector_type;
1309     dp->wide_bus_en = desc->wide_bus_en;
1310     dp->dp_display.is_edp =
1311         (dp->dp_display.connector_type == DRM_MODE_CONNECTOR_eDP);
1312 
1313     rc = dp_init_sub_modules(dp);
1314     if (rc) {
1315         DRM_ERROR("init sub module failed\n");
1316         return -EPROBE_DEFER;
1317     }
1318 
1319     /* setup event q */
1320     mutex_init(&dp->event_mutex);
1321     init_waitqueue_head(&dp->event_q);
1322     spin_lock_init(&dp->event_lock);
1323 
1324     /* Store DP audio handle inside DP display */
1325     dp->dp_display.dp_audio = dp->audio;
1326 
1327     init_completion(&dp->audio_comp);
1328 
1329     platform_set_drvdata(pdev, &dp->dp_display);
1330 
1331     rc = component_add(&pdev->dev, &dp_display_comp_ops);
1332     if (rc) {
1333         DRM_ERROR("component add failed, rc=%d\n", rc);
1334         dp_display_deinit_sub_modules(dp);
1335     }
1336 
1337     return rc;
1338 }
1339 
1340 static int dp_display_remove(struct platform_device *pdev)
1341 {
1342     struct dp_display_private *dp = dev_get_dp_display_private(&pdev->dev);
1343 
1344     dp_display_deinit_sub_modules(dp);
1345 
1346     component_del(&pdev->dev, &dp_display_comp_ops);
1347     platform_set_drvdata(pdev, NULL);
1348 
1349     return 0;
1350 }
1351 
1352 static int dp_pm_resume(struct device *dev)
1353 {
1354     struct platform_device *pdev = to_platform_device(dev);
1355     struct msm_dp *dp_display = platform_get_drvdata(pdev);
1356     struct dp_display_private *dp;
1357     int sink_count = 0;
1358 
1359     dp = container_of(dp_display, struct dp_display_private, dp_display);
1360 
1361     mutex_lock(&dp->event_mutex);
1362 
1363     drm_dbg_dp(dp->drm_dev,
1364         "Before, type=%d core_inited=%d phy_inited=%d power_on=%d\n",
1365         dp->dp_display.connector_type, dp->core_initialized,
1366         dp->phy_initialized, dp_display->power_on);
1367 
1368     /* start from disconnected state */
1369     dp->hpd_state = ST_DISCONNECTED;
1370 
1371     /* turn on dp ctrl/phy */
1372     dp_display_host_init(dp);
1373 
1374     dp_catalog_ctrl_hpd_config(dp->catalog);
1375 
1376 
1377     if (!dp->dp_display.is_edp)
1378         dp_catalog_hpd_config_intr(dp->catalog,
1379                 DP_DP_HPD_PLUG_INT_MASK |
1380                 DP_DP_HPD_UNPLUG_INT_MASK,
1381                 true);
1382 
1383     if (dp_catalog_link_is_connected(dp->catalog)) {
1384         /*
1385          * set sink to normal operation mode -- D0
1386          * before dpcd read
1387          */
1388         dp_display_host_phy_init(dp);
1389         dp_link_psm_config(dp->link, &dp->panel->link_info, false);
1390         sink_count = drm_dp_read_sink_count(dp->aux);
1391         if (sink_count < 0)
1392             sink_count = 0;
1393 
1394         dp_display_host_phy_exit(dp);
1395     }
1396 
1397     dp->link->sink_count = sink_count;
1398     /*
1399      * can not declared display is connected unless
1400      * HDMI cable is plugged in and sink_count of
1401      * dongle become 1
1402      * also only signal audio when disconnected
1403      */
1404     if (dp->link->sink_count) {
1405         dp->dp_display.is_connected = true;
1406     } else {
1407         dp->dp_display.is_connected = false;
1408         dp_display_handle_plugged_change(dp_display, false);
1409     }
1410 
1411     drm_dbg_dp(dp->drm_dev,
1412         "After, type=%d sink=%d conn=%d core_init=%d phy_init=%d power=%d\n",
1413         dp->dp_display.connector_type, dp->link->sink_count,
1414         dp->dp_display.is_connected, dp->core_initialized,
1415         dp->phy_initialized, dp_display->power_on);
1416 
1417     mutex_unlock(&dp->event_mutex);
1418 
1419     return 0;
1420 }
1421 
1422 static int dp_pm_suspend(struct device *dev)
1423 {
1424     struct platform_device *pdev = to_platform_device(dev);
1425     struct msm_dp *dp_display = platform_get_drvdata(pdev);
1426     struct dp_display_private *dp;
1427 
1428     dp = container_of(dp_display, struct dp_display_private, dp_display);
1429 
1430     mutex_lock(&dp->event_mutex);
1431 
1432     drm_dbg_dp(dp->drm_dev,
1433         "Before, type=%d core_inited=%d  phy_inited=%d power_on=%d\n",
1434         dp->dp_display.connector_type, dp->core_initialized,
1435         dp->phy_initialized, dp_display->power_on);
1436 
1437     /* mainlink enabled */
1438     if (dp_power_clk_status(dp->power, DP_CTRL_PM))
1439         dp_ctrl_off_link_stream(dp->ctrl);
1440 
1441     dp_display_host_phy_exit(dp);
1442 
1443     /* host_init will be called at pm_resume */
1444     dp_display_host_deinit(dp);
1445 
1446     dp->hpd_state = ST_SUSPENDED;
1447 
1448     drm_dbg_dp(dp->drm_dev,
1449         "After, type=%d core_inited=%d phy_inited=%d power_on=%d\n",
1450         dp->dp_display.connector_type, dp->core_initialized,
1451         dp->phy_initialized, dp_display->power_on);
1452 
1453     mutex_unlock(&dp->event_mutex);
1454 
1455     return 0;
1456 }
1457 
1458 static const struct dev_pm_ops dp_pm_ops = {
1459     .suspend = dp_pm_suspend,
1460     .resume =  dp_pm_resume,
1461 };
1462 
1463 static struct platform_driver dp_display_driver = {
1464     .probe  = dp_display_probe,
1465     .remove = dp_display_remove,
1466     .driver = {
1467         .name = "msm-dp-display",
1468         .of_match_table = dp_dt_match,
1469         .suppress_bind_attrs = true,
1470         .pm = &dp_pm_ops,
1471     },
1472 };
1473 
1474 int __init msm_dp_register(void)
1475 {
1476     int ret;
1477 
1478     ret = platform_driver_register(&dp_display_driver);
1479     if (ret)
1480         DRM_ERROR("Dp display driver register failed");
1481 
1482     return ret;
1483 }
1484 
1485 void __exit msm_dp_unregister(void)
1486 {
1487     platform_driver_unregister(&dp_display_driver);
1488 }
1489 
1490 void msm_dp_irq_postinstall(struct msm_dp *dp_display)
1491 {
1492     struct dp_display_private *dp;
1493 
1494     if (!dp_display)
1495         return;
1496 
1497     dp = container_of(dp_display, struct dp_display_private, dp_display);
1498 
1499     if (!dp_display->is_edp)
1500         dp_add_event(dp, EV_HPD_INIT_SETUP, 0, 100);
1501 }
1502 
1503 bool msm_dp_wide_bus_available(const struct msm_dp *dp_display)
1504 {
1505     struct dp_display_private *dp;
1506 
1507     dp = container_of(dp_display, struct dp_display_private, dp_display);
1508 
1509     return dp->wide_bus_en;
1510 }
1511 
1512 void msm_dp_debugfs_init(struct msm_dp *dp_display, struct drm_minor *minor)
1513 {
1514     struct dp_display_private *dp;
1515     struct device *dev;
1516     int rc;
1517 
1518     dp = container_of(dp_display, struct dp_display_private, dp_display);
1519     dev = &dp->pdev->dev;
1520 
1521     dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
1522                     dp->link, dp->dp_display.connector,
1523                     minor);
1524     if (IS_ERR(dp->debug)) {
1525         rc = PTR_ERR(dp->debug);
1526         DRM_ERROR("failed to initialize debug, rc = %d\n", rc);
1527         dp->debug = NULL;
1528     }
1529 }
1530 
1531 static int dp_display_get_next_bridge(struct msm_dp *dp)
1532 {
1533     int rc;
1534     struct dp_display_private *dp_priv;
1535     struct device_node *aux_bus;
1536     struct device *dev;
1537 
1538     dp_priv = container_of(dp, struct dp_display_private, dp_display);
1539     dev = &dp_priv->pdev->dev;
1540     aux_bus = of_get_child_by_name(dev->of_node, "aux-bus");
1541 
1542     if (aux_bus && dp->is_edp) {
1543         dp_display_host_init(dp_priv);
1544         dp_catalog_ctrl_hpd_config(dp_priv->catalog);
1545         dp_display_host_phy_init(dp_priv);
1546         enable_irq(dp_priv->irq);
1547 
1548         /*
1549          * The code below assumes that the panel will finish probing
1550          * by the time devm_of_dp_aux_populate_ep_devices() returns.
1551          * This isn't a great assumption since it will fail if the
1552          * panel driver is probed asynchronously but is the best we
1553          * can do without a bigger driver reorganization.
1554          */
1555         rc = devm_of_dp_aux_populate_ep_devices(dp_priv->aux);
1556         of_node_put(aux_bus);
1557         if (rc)
1558             goto error;
1559     } else if (dp->is_edp) {
1560         DRM_ERROR("eDP aux_bus not found\n");
1561         return -ENODEV;
1562     }
1563 
1564     /*
1565      * External bridges are mandatory for eDP interfaces: one has to
1566      * provide at least an eDP panel (which gets wrapped into panel-bridge).
1567      *
1568      * For DisplayPort interfaces external bridges are optional, so
1569      * silently ignore an error if one is not present (-ENODEV).
1570      */
1571     rc = dp_parser_find_next_bridge(dp_priv->parser);
1572     if (!dp->is_edp && rc == -ENODEV)
1573         return 0;
1574 
1575     if (!rc) {
1576         dp->next_bridge = dp_priv->parser->next_bridge;
1577         return 0;
1578     }
1579 
1580 error:
1581     if (dp->is_edp) {
1582         disable_irq(dp_priv->irq);
1583         dp_display_host_phy_exit(dp_priv);
1584         dp_display_host_deinit(dp_priv);
1585     }
1586     return rc;
1587 }
1588 
1589 int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
1590             struct drm_encoder *encoder)
1591 {
1592     struct msm_drm_private *priv;
1593     struct dp_display_private *dp_priv;
1594     int ret;
1595 
1596     if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
1597         return -EINVAL;
1598 
1599     priv = dev->dev_private;
1600     dp_display->drm_dev = dev;
1601 
1602     dp_priv = container_of(dp_display, struct dp_display_private, dp_display);
1603 
1604     ret = dp_display_request_irq(dp_display);
1605     if (ret) {
1606         DRM_ERROR("request_irq failed, ret=%d\n", ret);
1607         return ret;
1608     }
1609 
1610     ret = dp_display_get_next_bridge(dp_display);
1611     if (ret)
1612         return ret;
1613 
1614     dp_display->bridge = dp_bridge_init(dp_display, dev, encoder);
1615     if (IS_ERR(dp_display->bridge)) {
1616         ret = PTR_ERR(dp_display->bridge);
1617         DRM_DEV_ERROR(dev->dev,
1618             "failed to create dp bridge: %d\n", ret);
1619         dp_display->bridge = NULL;
1620         return ret;
1621     }
1622 
1623     priv->bridges[priv->num_bridges++] = dp_display->bridge;
1624 
1625     dp_display->connector = dp_drm_connector_init(dp_display, encoder);
1626     if (IS_ERR(dp_display->connector)) {
1627         ret = PTR_ERR(dp_display->connector);
1628         DRM_DEV_ERROR(dev->dev,
1629             "failed to create dp connector: %d\n", ret);
1630         dp_display->connector = NULL;
1631         return ret;
1632     }
1633 
1634     dp_priv->panel->connector = dp_display->connector;
1635 
1636     return 0;
1637 }
1638 
1639 void dp_bridge_enable(struct drm_bridge *drm_bridge)
1640 {
1641     struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1642     struct msm_dp *dp = dp_bridge->dp_display;
1643     int rc = 0;
1644     struct dp_display_private *dp_display;
1645     u32 state;
1646     bool force_link_train = false;
1647 
1648     dp_display = container_of(dp, struct dp_display_private, dp_display);
1649     if (!dp_display->dp_mode.drm_mode.clock) {
1650         DRM_ERROR("invalid params\n");
1651         return;
1652     }
1653 
1654     if (dp->is_edp)
1655         dp_hpd_plug_handle(dp_display, 0);
1656 
1657     mutex_lock(&dp_display->event_mutex);
1658 
1659     state = dp_display->hpd_state;
1660     if (state != ST_DISPLAY_OFF && state != ST_MAINLINK_READY) {
1661         mutex_unlock(&dp_display->event_mutex);
1662         return;
1663     }
1664 
1665     rc = dp_display_set_mode(dp, &dp_display->dp_mode);
1666     if (rc) {
1667         DRM_ERROR("Failed to perform a mode set, rc=%d\n", rc);
1668         mutex_unlock(&dp_display->event_mutex);
1669         return;
1670     }
1671 
1672     state =  dp_display->hpd_state;
1673 
1674     if (state == ST_DISPLAY_OFF) {
1675         dp_display_host_phy_init(dp_display);
1676         force_link_train = true;
1677     }
1678 
1679     dp_display_enable(dp_display, force_link_train);
1680 
1681     rc = dp_display_post_enable(dp);
1682     if (rc) {
1683         DRM_ERROR("DP display post enable failed, rc=%d\n", rc);
1684         dp_display_disable(dp_display);
1685     }
1686 
1687     /* completed connection */
1688     dp_display->hpd_state = ST_CONNECTED;
1689 
1690     drm_dbg_dp(dp->drm_dev, "type=%d Done\n", dp->connector_type);
1691     mutex_unlock(&dp_display->event_mutex);
1692 }
1693 
1694 void dp_bridge_disable(struct drm_bridge *drm_bridge)
1695 {
1696     struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1697     struct msm_dp *dp = dp_bridge->dp_display;
1698     struct dp_display_private *dp_display;
1699 
1700     dp_display = container_of(dp, struct dp_display_private, dp_display);
1701 
1702     dp_ctrl_push_idle(dp_display->ctrl);
1703 }
1704 
1705 void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
1706 {
1707     struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1708     struct msm_dp *dp = dp_bridge->dp_display;
1709     u32 state;
1710     struct dp_display_private *dp_display;
1711 
1712     dp_display = container_of(dp, struct dp_display_private, dp_display);
1713 
1714     if (dp->is_edp)
1715         dp_hpd_unplug_handle(dp_display, 0);
1716 
1717     mutex_lock(&dp_display->event_mutex);
1718 
1719     state = dp_display->hpd_state;
1720     if (state != ST_DISCONNECT_PENDING && state != ST_CONNECTED) {
1721         mutex_unlock(&dp_display->event_mutex);
1722         return;
1723     }
1724 
1725     dp_display_disable(dp_display);
1726 
1727     state =  dp_display->hpd_state;
1728     if (state == ST_DISCONNECT_PENDING) {
1729         /* completed disconnection */
1730         dp_display->hpd_state = ST_DISCONNECTED;
1731     } else {
1732         dp_display->hpd_state = ST_DISPLAY_OFF;
1733     }
1734 
1735     drm_dbg_dp(dp->drm_dev, "type=%d Done\n", dp->connector_type);
1736     mutex_unlock(&dp_display->event_mutex);
1737 }
1738 
1739 void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
1740             const struct drm_display_mode *mode,
1741             const struct drm_display_mode *adjusted_mode)
1742 {
1743     struct msm_dp_bridge *dp_bridge = to_dp_bridge(drm_bridge);
1744     struct msm_dp *dp = dp_bridge->dp_display;
1745     struct dp_display_private *dp_display;
1746 
1747     dp_display = container_of(dp, struct dp_display_private, dp_display);
1748 
1749     memset(&dp_display->dp_mode, 0x0, sizeof(struct dp_display_mode));
1750 
1751     if (dp_display_check_video_test(dp))
1752         dp_display->dp_mode.bpp = dp_display_get_test_bpp(dp);
1753     else /* Default num_components per pixel = 3 */
1754         dp_display->dp_mode.bpp = dp->connector->display_info.bpc * 3;
1755 
1756     if (!dp_display->dp_mode.bpp)
1757         dp_display->dp_mode.bpp = 24; /* Default bpp */
1758 
1759     drm_mode_copy(&dp_display->dp_mode.drm_mode, adjusted_mode);
1760 
1761     dp_display->dp_mode.v_active_low =
1762         !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NVSYNC);
1763 
1764     dp_display->dp_mode.h_active_low =
1765         !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NHSYNC);
1766 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!