1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
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>
17 #include "dp_parser.h"
19 #include "dp_catalog.h"
25 #include "dp_display.h"
30 static struct msm_dp *g_dp_display;
31 #define HPD_STRING_SIZE 30
38 ISR_IRQ_HPD_PULSE_COUNT,
39 ISR_HPD_LO_GLITH_COUNT,
42 /* event thread connection state */
47 ST_DISCONNECT_PENDING,
61 EV_CONNECT_PENDING_TIMEOUT,
62 EV_DISCONNECT_PENDING_TIMEOUT,
65 #define EVENT_TIMEOUT (HZ/10) /* 100ms */
66 #define DP_EVENT_Q_MAX 8
68 #define DP_TIMEOUT_5_SECOND (5000/EVENT_TIMEOUT)
69 #define DP_TIMEOUT_NONE 0
71 #define WAIT_FOR_RESUME_TIMEOUT_JIFFIES (HZ / 2)
79 struct dp_display_private {
84 bool core_initialized;
88 struct platform_device *pdev;
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;
97 struct dp_panel *panel;
99 struct dp_debug *debug;
101 struct dp_usbpd_cb usbpd_cb;
102 struct dp_display_mode dp_mode;
103 struct msm_dp dp_display;
105 bool encoder_mode_set;
107 /* wait for audio signaling */
108 struct completion audio_comp;
110 /* event related only access by event thread */
111 struct mutex event_mutex;
112 wait_queue_head_t event_q;
116 struct dp_event event_list[DP_EVENT_Q_MAX];
117 spinlock_t event_lock;
119 struct dp_audio *audio;
122 static const struct of_device_id dp_dt_match[] = {
123 {.compatible = "qcom,sc7180-dp"},
127 static int dp_add_event(struct dp_display_private *dp_priv, u32 event,
131 struct dp_event *todo;
134 spin_lock_irqsave(&dp_priv->event_lock, flag);
135 pndx = dp_priv->event_pndx + 1;
136 pndx %= DP_EVENT_Q_MAX;
137 if (pndx == dp_priv->event_gndx) {
138 pr_err("event_q is full: pndx=%d gndx=%d\n",
139 dp_priv->event_pndx, dp_priv->event_gndx);
140 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
143 todo = &dp_priv->event_list[dp_priv->event_pndx++];
144 dp_priv->event_pndx %= DP_EVENT_Q_MAX;
145 todo->event_id = event;
148 wake_up(&dp_priv->event_q);
149 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
154 static int dp_del_event(struct dp_display_private *dp_priv, u32 event)
157 struct dp_event *todo;
160 spin_lock_irqsave(&dp_priv->event_lock, flag);
161 if (dp_priv->event_pndx == dp_priv->event_gndx) {
162 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
166 gndx = dp_priv->event_gndx;
167 while (dp_priv->event_pndx != gndx) {
168 todo = &dp_priv->event_list[gndx];
169 if (todo->event_id == event) {
170 todo->event_id = EV_NO_EVENT; /* deleted */
174 gndx %= DP_EVENT_Q_MAX;
176 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
181 void dp_display_signal_audio_start(struct msm_dp *dp_display)
183 struct dp_display_private *dp;
185 dp = container_of(dp_display, struct dp_display_private, dp_display);
187 reinit_completion(&dp->audio_comp);
190 void dp_display_signal_audio_complete(struct msm_dp *dp_display)
192 struct dp_display_private *dp;
194 dp = container_of(dp_display, struct dp_display_private, dp_display);
196 complete_all(&dp->audio_comp);
199 static int dp_display_bind(struct device *dev, struct device *master,
203 struct dp_display_private *dp;
204 struct drm_device *drm;
205 struct msm_drm_private *priv;
207 drm = dev_get_drvdata(master);
209 dp = container_of(g_dp_display,
210 struct dp_display_private, dp_display);
212 DRM_ERROR("DP driver bind failed. Invalid driver data\n");
216 dp->dp_display.drm_dev = drm;
217 priv = drm->dev_private;
218 priv->dp = &(dp->dp_display);
220 rc = dp->parser->parse(dp->parser);
222 DRM_ERROR("device tree parsing failed\n");
226 rc = dp_aux_register(dp->aux);
228 DRM_ERROR("DRM DP AUX register failed\n");
232 rc = dp_power_client_init(dp->power);
234 DRM_ERROR("Power client create failed\n");
238 rc = dp_register_audio_driver(dev, dp->audio);
240 DRM_ERROR("Audio registration Dp failed\n");
246 static void dp_display_unbind(struct device *dev, struct device *master,
249 struct dp_display_private *dp;
250 struct drm_device *drm = dev_get_drvdata(master);
251 struct msm_drm_private *priv = drm->dev_private;
253 dp = container_of(g_dp_display,
254 struct dp_display_private, dp_display);
256 DRM_ERROR("Invalid DP driver data\n");
260 dp_power_client_deinit(dp->power);
261 dp_aux_unregister(dp->aux);
265 static const struct component_ops dp_display_comp_ops = {
266 .bind = dp_display_bind,
267 .unbind = dp_display_unbind,
270 static bool dp_display_is_ds_bridge(struct dp_panel *panel)
272 return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
273 DP_DWN_STRM_PORT_PRESENT);
276 static bool dp_display_is_sink_count_zero(struct dp_display_private *dp)
278 return dp_display_is_ds_bridge(dp->panel) &&
279 (dp->link->sink_count == 0);
282 static void dp_display_send_hpd_event(struct msm_dp *dp_display)
284 struct dp_display_private *dp;
285 struct drm_connector *connector;
287 dp = container_of(dp_display, struct dp_display_private, dp_display);
289 connector = dp->dp_display.connector;
290 drm_helper_hpd_irq_event(connector->dev);
294 static void dp_display_set_encoder_mode(struct dp_display_private *dp)
296 struct msm_drm_private *priv = dp->dp_display.drm_dev->dev_private;
297 struct msm_kms *kms = priv->kms;
299 if (!dp->encoder_mode_set && dp->dp_display.encoder &&
300 kms->funcs->set_encoder_mode) {
301 kms->funcs->set_encoder_mode(kms,
302 dp->dp_display.encoder, false);
304 dp->encoder_mode_set = true;
308 static int dp_display_send_hpd_notification(struct dp_display_private *dp,
311 if ((hpd && dp->dp_display.is_connected) ||
312 (!hpd && !dp->dp_display.is_connected)) {
313 DRM_DEBUG_DP("HPD already %s\n", (hpd ? "on" : "off"));
317 /* reset video pattern flag on disconnect */
319 dp->panel->video_test = false;
321 dp->dp_display.is_connected = hpd;
323 dp_display_send_hpd_event(&dp->dp_display);
328 static int dp_display_process_hpd_high(struct dp_display_private *dp)
333 dp->panel->max_dp_lanes = dp->parser->max_dp_lanes;
335 rc = dp_panel_read_sink_caps(dp->panel, dp->dp_display.connector);
339 dp_link_process_request(dp->link);
341 edid = dp->panel->edid;
343 dp->audio_supported = drm_detect_monitor_audio(edid);
344 dp_panel_handle_sink_request(dp->panel);
346 dp->dp_display.max_pclk_khz = DP_MAX_PIXEL_CLK_KHZ;
347 dp->dp_display.max_dp_lanes = dp->parser->max_dp_lanes;
349 dp_link_reset_phy_params_vx_px(dp->link);
350 rc = dp_ctrl_on_link(dp->ctrl);
352 DRM_ERROR("failed to complete DP link training\n");
356 dp_add_event(dp, EV_USER_NOTIFICATION, true, 0);
362 static void dp_display_host_init(struct dp_display_private *dp, int reset)
366 if (dp->core_initialized) {
367 DRM_DEBUG_DP("DP core already initialized\n");
371 if (dp->usbpd->orientation == ORIENTATION_CC2)
374 dp_display_set_encoder_mode(dp);
376 dp_power_init(dp->power, flip);
377 dp_ctrl_host_init(dp->ctrl, flip, reset);
378 dp_aux_init(dp->aux);
379 dp->core_initialized = true;
382 static void dp_display_host_deinit(struct dp_display_private *dp)
384 if (!dp->core_initialized) {
385 DRM_DEBUG_DP("DP core not initialized\n");
389 dp_ctrl_host_deinit(dp->ctrl);
390 dp_aux_deinit(dp->aux);
391 dp_power_deinit(dp->power);
393 dp->core_initialized = false;
396 static int dp_display_usbpd_configure_cb(struct device *dev)
399 struct dp_display_private *dp;
402 DRM_ERROR("invalid dev\n");
407 dp = container_of(g_dp_display,
408 struct dp_display_private, dp_display);
410 DRM_ERROR("no driver data found\n");
415 dp_display_host_init(dp, false);
418 * set sink to normal operation mode -- D0
421 dp_link_psm_config(dp->link, &dp->panel->link_info, false);
422 rc = dp_display_process_hpd_high(dp);
427 static int dp_display_usbpd_disconnect_cb(struct device *dev)
430 struct dp_display_private *dp;
433 DRM_ERROR("invalid dev\n");
438 dp = container_of(g_dp_display,
439 struct dp_display_private, dp_display);
441 DRM_ERROR("no driver data found\n");
446 dp_add_event(dp, EV_USER_NOTIFICATION, false, 0);
451 static void dp_display_handle_video_request(struct dp_display_private *dp)
453 if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
454 dp->panel->video_test = true;
455 dp_link_send_test_response(dp->link);
459 static int dp_display_handle_port_ststus_changed(struct dp_display_private *dp)
463 if (dp_display_is_sink_count_zero(dp)) {
464 DRM_DEBUG_DP("sink count is zero, nothing to do\n");
465 if (dp->hpd_state != ST_DISCONNECTED) {
466 dp->hpd_state = ST_DISCONNECT_PENDING;
467 dp_add_event(dp, EV_USER_NOTIFICATION, false, 0);
470 if (dp->hpd_state == ST_DISCONNECTED) {
471 dp->hpd_state = ST_CONNECT_PENDING;
472 rc = dp_display_process_hpd_high(dp);
474 dp->hpd_state = ST_DISCONNECTED;
481 static int dp_display_handle_irq_hpd(struct dp_display_private *dp)
483 u32 sink_request = dp->link->sink_request;
485 if (dp->hpd_state == ST_DISCONNECTED) {
486 if (sink_request & DP_LINK_STATUS_UPDATED) {
487 DRM_ERROR("Disconnected, no DP_LINK_STATUS_UPDATED\n");
492 dp_ctrl_handle_sink_request(dp->ctrl);
494 if (sink_request & DP_TEST_LINK_VIDEO_PATTERN)
495 dp_display_handle_video_request(dp);
500 static int dp_display_usbpd_attention_cb(struct device *dev)
504 struct dp_display_private *dp;
505 struct dp_usbpd *hpd;
508 DRM_ERROR("invalid dev\n");
512 dp = container_of(g_dp_display,
513 struct dp_display_private, dp_display);
515 DRM_ERROR("no driver data found\n");
521 /* check for any test request issued by sink */
522 rc = dp_link_process_request(dp->link);
524 sink_request = dp->link->sink_request;
525 if (sink_request & DS_PORT_STATUS_CHANGED)
526 rc = dp_display_handle_port_ststus_changed(dp);
528 rc = dp_display_handle_irq_hpd(dp);
534 static int dp_hpd_plug_handle(struct dp_display_private *dp, u32 data)
536 struct dp_usbpd *hpd = dp->usbpd;
538 u32 tout = DP_TIMEOUT_5_SECOND;
544 mutex_lock(&dp->event_mutex);
546 state = dp->hpd_state;
547 if (state == ST_DISPLAY_OFF || state == ST_SUSPENDED) {
548 mutex_unlock(&dp->event_mutex);
552 if (state == ST_CONNECT_PENDING || state == ST_CONNECTED) {
553 mutex_unlock(&dp->event_mutex);
557 if (state == ST_DISCONNECT_PENDING) {
558 /* wait until ST_DISCONNECTED */
559 dp_add_event(dp, EV_HPD_PLUG_INT, 0, 1); /* delay = 1 */
560 mutex_unlock(&dp->event_mutex);
564 dp->hpd_state = ST_CONNECT_PENDING;
568 ret = dp_display_usbpd_configure_cb(&dp->pdev->dev);
569 if (ret) { /* link train failed */
571 dp->hpd_state = ST_DISCONNECTED;
573 if (ret == -ECONNRESET) { /* cable unplugged */
574 dp->core_initialized = false;
578 /* start sentinel checking in case of missing uevent */
579 dp_add_event(dp, EV_CONNECT_PENDING_TIMEOUT, 0, tout);
582 mutex_unlock(&dp->event_mutex);
584 /* uevent will complete connection part */
588 static int dp_display_enable(struct dp_display_private *dp, u32 data);
589 static int dp_display_disable(struct dp_display_private *dp, u32 data);
591 static int dp_connect_pending_timeout(struct dp_display_private *dp, u32 data)
595 mutex_lock(&dp->event_mutex);
597 state = dp->hpd_state;
598 if (state == ST_CONNECT_PENDING)
599 dp->hpd_state = ST_CONNECTED;
601 mutex_unlock(&dp->event_mutex);
606 static void dp_display_handle_plugged_change(struct msm_dp *dp_display,
609 struct dp_display_private *dp;
611 dp = container_of(dp_display,
612 struct dp_display_private, dp_display);
614 /* notify audio subsystem only if sink supports audio */
615 if (dp_display->plugged_cb && dp_display->codec_dev &&
617 dp_display->plugged_cb(dp_display->codec_dev, plugged);
620 static int dp_hpd_unplug_handle(struct dp_display_private *dp, u32 data)
622 struct dp_usbpd *hpd = dp->usbpd;
628 mutex_lock(&dp->event_mutex);
630 state = dp->hpd_state;
631 if (state == ST_DISCONNECT_PENDING || state == ST_DISCONNECTED) {
632 mutex_unlock(&dp->event_mutex);
636 if (state == ST_CONNECT_PENDING) {
637 /* wait until CONNECTED */
638 dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 1); /* delay = 1 */
639 mutex_unlock(&dp->event_mutex);
643 dp->hpd_state = ST_DISCONNECT_PENDING;
645 /* disable HPD plug interrupt until disconnect is done */
646 dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK
647 | DP_DP_IRQ_HPD_INT_MASK, false);
652 * We don't need separate work for disconnect as
653 * connect/attention interrupts are disabled
655 dp_display_usbpd_disconnect_cb(&dp->pdev->dev);
657 /* start sentinel checking in case of missing uevent */
658 dp_add_event(dp, EV_DISCONNECT_PENDING_TIMEOUT, 0, DP_TIMEOUT_5_SECOND);
660 /* signal the disconnect event early to ensure proper teardown */
661 dp_display_handle_plugged_change(g_dp_display, false);
663 dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK |
664 DP_DP_IRQ_HPD_INT_MASK, true);
666 /* uevent will complete disconnection part */
667 mutex_unlock(&dp->event_mutex);
671 static int dp_disconnect_pending_timeout(struct dp_display_private *dp, u32 data)
675 mutex_lock(&dp->event_mutex);
677 state = dp->hpd_state;
678 if (state == ST_DISCONNECT_PENDING)
679 dp->hpd_state = ST_DISCONNECTED;
681 mutex_unlock(&dp->event_mutex);
686 static int dp_irq_hpd_handle(struct dp_display_private *dp, u32 data)
691 mutex_lock(&dp->event_mutex);
693 /* irq_hpd can happen at either connected or disconnected state */
694 state = dp->hpd_state;
695 if (state == ST_DISPLAY_OFF) {
696 mutex_unlock(&dp->event_mutex);
700 if (state == ST_CONNECT_PENDING) {
701 /* wait until ST_CONNECTED */
702 dp_add_event(dp, EV_IRQ_HPD_INT, 0, 1); /* delay = 1 */
703 mutex_unlock(&dp->event_mutex);
707 if (state == ST_CONNECT_PENDING || state == ST_DISCONNECT_PENDING) {
708 /* wait until ST_CONNECTED */
709 dp_add_event(dp, EV_IRQ_HPD_INT, 0, 1); /* delay = 1 */
710 mutex_unlock(&dp->event_mutex);
714 ret = dp_display_usbpd_attention_cb(&dp->pdev->dev);
715 if (ret == -ECONNRESET) { /* cable unplugged */
716 dp->core_initialized = false;
719 mutex_unlock(&dp->event_mutex);
724 static void dp_display_deinit_sub_modules(struct dp_display_private *dp)
726 dp_debug_put(dp->debug);
727 dp_ctrl_put(dp->ctrl);
728 dp_panel_put(dp->panel);
730 dp_audio_put(dp->audio);
733 static int dp_init_sub_modules(struct dp_display_private *dp)
736 struct device *dev = &dp->pdev->dev;
737 struct dp_usbpd_cb *cb = &dp->usbpd_cb;
738 struct dp_panel_in panel_in = {
742 /* Callback APIs used for cable status change event */
743 cb->configure = dp_display_usbpd_configure_cb;
744 cb->disconnect = dp_display_usbpd_disconnect_cb;
745 cb->attention = dp_display_usbpd_attention_cb;
747 dp->usbpd = dp_hpd_get(dev, cb);
748 if (IS_ERR(dp->usbpd)) {
749 rc = PTR_ERR(dp->usbpd);
750 DRM_ERROR("failed to initialize hpd, rc = %d\n", rc);
755 dp->parser = dp_parser_get(dp->pdev);
756 if (IS_ERR(dp->parser)) {
757 rc = PTR_ERR(dp->parser);
758 DRM_ERROR("failed to initialize parser, rc = %d\n", rc);
763 dp->catalog = dp_catalog_get(dev, &dp->parser->io);
764 if (IS_ERR(dp->catalog)) {
765 rc = PTR_ERR(dp->catalog);
766 DRM_ERROR("failed to initialize catalog, rc = %d\n", rc);
771 dp->power = dp_power_get(dev, dp->parser);
772 if (IS_ERR(dp->power)) {
773 rc = PTR_ERR(dp->power);
774 DRM_ERROR("failed to initialize power, rc = %d\n", rc);
779 dp->aux = dp_aux_get(dev, dp->catalog);
780 if (IS_ERR(dp->aux)) {
781 rc = PTR_ERR(dp->aux);
782 DRM_ERROR("failed to initialize aux, rc = %d\n", rc);
787 dp->link = dp_link_get(dev, dp->aux);
788 if (IS_ERR(dp->link)) {
789 rc = PTR_ERR(dp->link);
790 DRM_ERROR("failed to initialize link, rc = %d\n", rc);
795 panel_in.aux = dp->aux;
796 panel_in.catalog = dp->catalog;
797 panel_in.link = dp->link;
799 dp->panel = dp_panel_get(&panel_in);
800 if (IS_ERR(dp->panel)) {
801 rc = PTR_ERR(dp->panel);
802 DRM_ERROR("failed to initialize panel, rc = %d\n", rc);
807 dp->ctrl = dp_ctrl_get(dev, dp->link, dp->panel, dp->aux,
808 dp->power, dp->catalog, dp->parser);
809 if (IS_ERR(dp->ctrl)) {
810 rc = PTR_ERR(dp->ctrl);
811 DRM_ERROR("failed to initialize ctrl, rc = %d\n", rc);
816 dp->audio = dp_audio_get(dp->pdev, dp->panel, dp->catalog);
817 if (IS_ERR(dp->audio)) {
818 rc = PTR_ERR(dp->audio);
819 pr_err("failed to initialize audio, rc = %d\n", rc);
827 dp_ctrl_put(dp->ctrl);
829 dp_panel_put(dp->panel);
836 static int dp_display_set_mode(struct msm_dp *dp_display,
837 struct dp_display_mode *mode)
839 struct dp_display_private *dp;
841 dp = container_of(dp_display, struct dp_display_private, dp_display);
843 dp->panel->dp_mode.drm_mode = mode->drm_mode;
844 dp->panel->dp_mode.bpp = mode->bpp;
845 dp->panel->dp_mode.capabilities = mode->capabilities;
846 dp_panel_init_panel_info(dp->panel);
850 static int dp_display_prepare(struct msm_dp *dp)
855 static int dp_display_enable(struct dp_display_private *dp, u32 data)
858 struct msm_dp *dp_display;
860 dp_display = g_dp_display;
862 if (dp_display->power_on) {
863 DRM_DEBUG_DP("Link already setup, return\n");
867 rc = dp_ctrl_on_stream(dp->ctrl);
869 dp_display->power_on = true;
874 static int dp_display_post_enable(struct msm_dp *dp_display)
876 struct dp_display_private *dp;
879 dp = container_of(dp_display, struct dp_display_private, dp_display);
881 rate = dp->link->link_params.rate;
883 if (dp->audio_supported) {
884 dp->audio->bw_code = drm_dp_link_rate_to_bw_code(rate);
885 dp->audio->lane_count = dp->link->link_params.num_lanes;
888 /* signal the connect event late to synchronize video and display */
889 dp_display_handle_plugged_change(dp_display, true);
893 static int dp_display_disable(struct dp_display_private *dp, u32 data)
895 struct msm_dp *dp_display;
897 dp_display = g_dp_display;
899 if (!dp_display->power_on)
902 /* wait only if audio was enabled */
903 if (dp_display->audio_enabled) {
904 /* signal the disconnect event */
905 dp_display_handle_plugged_change(dp_display, false);
906 if (!wait_for_completion_timeout(&dp->audio_comp,
908 DRM_ERROR("audio comp timeout\n");
911 dp_display->audio_enabled = false;
913 dp_ctrl_off(dp->ctrl);
915 dp->core_initialized = false;
917 dp_display->power_on = false;
922 static int dp_display_unprepare(struct msm_dp *dp)
927 int dp_display_set_plugged_cb(struct msm_dp *dp_display,
928 hdmi_codec_plugged_cb fn, struct device *codec_dev)
932 dp_display->plugged_cb = fn;
933 dp_display->codec_dev = codec_dev;
934 plugged = dp_display->is_connected;
935 dp_display_handle_plugged_change(dp_display, plugged);
940 int dp_display_validate_mode(struct msm_dp *dp, u32 mode_pclk_khz)
942 const u32 num_components = 3, default_bpp = 24;
943 struct dp_display_private *dp_display;
944 struct dp_link_info *link_info;
945 u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
947 if (!dp || !mode_pclk_khz || !dp->connector) {
948 DRM_ERROR("invalid params\n");
952 dp_display = container_of(dp, struct dp_display_private, dp_display);
953 link_info = &dp_display->panel->link_info;
955 mode_bpp = dp->connector->display_info.bpc * num_components;
957 mode_bpp = default_bpp;
959 mode_bpp = dp_panel_get_mode_bpp(dp_display->panel,
960 mode_bpp, mode_pclk_khz);
962 mode_rate_khz = mode_pclk_khz * mode_bpp;
963 supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
965 if (mode_rate_khz > supported_rate_khz)
971 int dp_display_get_modes(struct msm_dp *dp,
972 struct dp_display_mode *dp_mode)
974 struct dp_display_private *dp_display;
978 DRM_ERROR("invalid params\n");
982 dp_display = container_of(dp, struct dp_display_private, dp_display);
984 ret = dp_panel_get_modes(dp_display->panel,
985 dp->connector, dp_mode);
986 if (dp_mode->drm_mode.clock)
987 dp->max_pclk_khz = dp_mode->drm_mode.clock;
991 bool dp_display_check_video_test(struct msm_dp *dp)
993 struct dp_display_private *dp_display;
995 dp_display = container_of(dp, struct dp_display_private, dp_display);
997 return dp_display->panel->video_test;
1000 int dp_display_get_test_bpp(struct msm_dp *dp)
1002 struct dp_display_private *dp_display;
1005 DRM_ERROR("invalid params\n");
1009 dp_display = container_of(dp, struct dp_display_private, dp_display);
1011 return dp_link_bit_depth_to_bpp(
1012 dp_display->link->test_video.test_bit_depth);
1015 static void dp_display_config_hpd(struct dp_display_private *dp)
1018 dp_display_host_init(dp, true);
1019 dp_catalog_ctrl_hpd_config(dp->catalog);
1021 /* Enable interrupt first time
1022 * we are leaving dp clocks on during disconnect
1023 * and never disable interrupt
1025 enable_irq(dp->irq);
1028 static int hpd_event_thread(void *data)
1030 struct dp_display_private *dp_priv;
1032 struct dp_event *todo;
1033 int timeout_mode = 0;
1035 dp_priv = (struct dp_display_private *)data;
1039 wait_event_timeout(dp_priv->event_q,
1040 (dp_priv->event_pndx == dp_priv->event_gndx),
1043 wait_event_interruptible(dp_priv->event_q,
1044 (dp_priv->event_pndx != dp_priv->event_gndx));
1046 spin_lock_irqsave(&dp_priv->event_lock, flag);
1047 todo = &dp_priv->event_list[dp_priv->event_gndx];
1049 struct dp_event *todo_next;
1051 dp_priv->event_gndx++;
1052 dp_priv->event_gndx %= DP_EVENT_Q_MAX;
1054 /* re enter delay event into q */
1055 todo_next = &dp_priv->event_list[dp_priv->event_pndx++];
1056 dp_priv->event_pndx %= DP_EVENT_Q_MAX;
1057 todo_next->event_id = todo->event_id;
1058 todo_next->data = todo->data;
1059 todo_next->delay = todo->delay - 1;
1061 /* clean up older event */
1062 todo->event_id = EV_NO_EVENT;
1065 /* switch to timeout mode */
1067 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1071 /* timeout with no events in q */
1072 if (dp_priv->event_pndx == dp_priv->event_gndx) {
1073 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1077 dp_priv->event_gndx++;
1078 dp_priv->event_gndx %= DP_EVENT_Q_MAX;
1080 spin_unlock_irqrestore(&dp_priv->event_lock, flag);
1082 switch (todo->event_id) {
1083 case EV_HPD_INIT_SETUP:
1084 dp_display_config_hpd(dp_priv);
1086 case EV_HPD_PLUG_INT:
1087 dp_hpd_plug_handle(dp_priv, todo->data);
1089 case EV_HPD_UNPLUG_INT:
1090 dp_hpd_unplug_handle(dp_priv, todo->data);
1092 case EV_IRQ_HPD_INT:
1093 dp_irq_hpd_handle(dp_priv, todo->data);
1095 case EV_HPD_REPLUG_INT:
1098 case EV_USER_NOTIFICATION:
1099 dp_display_send_hpd_notification(dp_priv,
1102 case EV_CONNECT_PENDING_TIMEOUT:
1103 dp_connect_pending_timeout(dp_priv,
1106 case EV_DISCONNECT_PENDING_TIMEOUT:
1107 dp_disconnect_pending_timeout(dp_priv,
1118 static void dp_hpd_event_setup(struct dp_display_private *dp_priv)
1120 init_waitqueue_head(&dp_priv->event_q);
1121 spin_lock_init(&dp_priv->event_lock);
1123 kthread_run(hpd_event_thread, dp_priv, "dp_hpd_handler");
1126 static irqreturn_t dp_display_irq_handler(int irq, void *dev_id)
1128 struct dp_display_private *dp = dev_id;
1129 irqreturn_t ret = IRQ_HANDLED;
1133 DRM_ERROR("invalid data\n");
1137 hpd_isr_status = dp_catalog_hpd_get_intr_status(dp->catalog);
1139 if (hpd_isr_status & 0x0F) {
1140 /* hpd related interrupts */
1141 if (hpd_isr_status & DP_DP_HPD_PLUG_INT_MASK ||
1142 hpd_isr_status & DP_DP_HPD_REPLUG_INT_MASK) {
1143 dp_add_event(dp, EV_HPD_PLUG_INT, 0, 0);
1146 if (hpd_isr_status & DP_DP_IRQ_HPD_INT_MASK) {
1147 /* stop sentinel connect pending checking */
1148 dp_del_event(dp, EV_CONNECT_PENDING_TIMEOUT);
1149 dp_add_event(dp, EV_IRQ_HPD_INT, 0, 0);
1152 if (hpd_isr_status & DP_DP_HPD_REPLUG_INT_MASK)
1153 dp_add_event(dp, EV_HPD_REPLUG_INT, 0, 0);
1155 if (hpd_isr_status & DP_DP_HPD_UNPLUG_INT_MASK)
1156 dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0);
1159 /* DP controller isr */
1160 dp_ctrl_isr(dp->ctrl);
1163 dp_aux_isr(dp->aux);
1168 int dp_display_request_irq(struct msm_dp *dp_display)
1171 struct dp_display_private *dp;
1174 DRM_ERROR("invalid input\n");
1178 dp = container_of(dp_display, struct dp_display_private, dp_display);
1180 dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
1183 DRM_ERROR("failed to get irq: %d\n", rc);
1187 rc = devm_request_irq(&dp->pdev->dev, dp->irq,
1188 dp_display_irq_handler,
1189 IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
1191 DRM_ERROR("failed to request IRQ%u: %d\n",
1195 disable_irq(dp->irq);
1200 static int dp_display_probe(struct platform_device *pdev)
1203 struct dp_display_private *dp;
1205 if (!pdev || !pdev->dev.of_node) {
1206 DRM_ERROR("pdev not found\n");
1210 dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
1215 dp->name = "drm_dp";
1217 rc = dp_init_sub_modules(dp);
1219 DRM_ERROR("init sub module failed\n");
1220 return -EPROBE_DEFER;
1223 mutex_init(&dp->event_mutex);
1224 g_dp_display = &dp->dp_display;
1226 /* Store DP audio handle inside DP display */
1227 g_dp_display->dp_audio = dp->audio;
1229 init_completion(&dp->audio_comp);
1231 platform_set_drvdata(pdev, g_dp_display);
1233 rc = component_add(&pdev->dev, &dp_display_comp_ops);
1235 DRM_ERROR("component add failed, rc=%d\n", rc);
1236 dp_display_deinit_sub_modules(dp);
1242 static int dp_display_remove(struct platform_device *pdev)
1244 struct dp_display_private *dp;
1246 dp = container_of(g_dp_display,
1247 struct dp_display_private, dp_display);
1249 dp_display_deinit_sub_modules(dp);
1251 component_del(&pdev->dev, &dp_display_comp_ops);
1252 platform_set_drvdata(pdev, NULL);
1257 static int dp_pm_resume(struct device *dev)
1259 struct platform_device *pdev = to_platform_device(dev);
1260 struct msm_dp *dp_display = platform_get_drvdata(pdev);
1261 struct dp_display_private *dp;
1264 dp = container_of(dp_display, struct dp_display_private, dp_display);
1266 mutex_lock(&dp->event_mutex);
1268 /* start from disconnected state */
1269 dp->hpd_state = ST_DISCONNECTED;
1271 /* turn on dp ctrl/phy */
1272 dp_display_host_init(dp, true);
1274 dp_catalog_ctrl_hpd_config(dp->catalog);
1276 status = dp_catalog_link_is_connected(dp->catalog);
1279 * can not declared display is connected unless
1280 * HDMI cable is plugged in and sink_count of
1283 if (status && dp->link->sink_count)
1284 dp->dp_display.is_connected = true;
1286 dp->dp_display.is_connected = false;
1288 mutex_unlock(&dp->event_mutex);
1293 static int dp_pm_suspend(struct device *dev)
1295 struct platform_device *pdev = to_platform_device(dev);
1296 struct msm_dp *dp_display = platform_get_drvdata(pdev);
1297 struct dp_display_private *dp;
1299 dp = container_of(dp_display, struct dp_display_private, dp_display);
1301 mutex_lock(&dp->event_mutex);
1303 if (dp->core_initialized == true)
1304 dp_display_host_deinit(dp);
1306 dp->hpd_state = ST_SUSPENDED;
1308 /* host_init will be called at pm_resume */
1309 dp->core_initialized = false;
1311 mutex_unlock(&dp->event_mutex);
1316 static int dp_pm_prepare(struct device *dev)
1321 static void dp_pm_complete(struct device *dev)
1326 static const struct dev_pm_ops dp_pm_ops = {
1327 .suspend = dp_pm_suspend,
1328 .resume = dp_pm_resume,
1329 .prepare = dp_pm_prepare,
1330 .complete = dp_pm_complete,
1333 static struct platform_driver dp_display_driver = {
1334 .probe = dp_display_probe,
1335 .remove = dp_display_remove,
1337 .name = "msm-dp-display",
1338 .of_match_table = dp_dt_match,
1339 .suppress_bind_attrs = true,
1344 int __init msm_dp_register(void)
1348 ret = platform_driver_register(&dp_display_driver);
1350 DRM_ERROR("Dp display driver register failed");
1355 void __exit msm_dp_unregister(void)
1357 platform_driver_unregister(&dp_display_driver);
1360 void msm_dp_irq_postinstall(struct msm_dp *dp_display)
1362 struct dp_display_private *dp;
1367 dp = container_of(dp_display, struct dp_display_private, dp_display);
1369 dp_hpd_event_setup(dp);
1371 dp_add_event(dp, EV_HPD_INIT_SETUP, 0, 100);
1374 void msm_dp_debugfs_init(struct msm_dp *dp_display, struct drm_minor *minor)
1376 struct dp_display_private *dp;
1380 dp = container_of(dp_display, struct dp_display_private, dp_display);
1381 dev = &dp->pdev->dev;
1383 dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
1384 dp->link, &dp->dp_display.connector,
1386 if (IS_ERR(dp->debug)) {
1387 rc = PTR_ERR(dp->debug);
1388 DRM_ERROR("failed to initialize debug, rc = %d\n", rc);
1393 int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
1394 struct drm_encoder *encoder)
1396 struct msm_drm_private *priv;
1399 if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
1402 priv = dev->dev_private;
1403 dp_display->drm_dev = dev;
1405 ret = dp_display_request_irq(dp_display);
1407 DRM_ERROR("request_irq failed, ret=%d\n", ret);
1411 dp_display->encoder = encoder;
1413 dp_display->connector = dp_drm_connector_init(dp_display);
1414 if (IS_ERR(dp_display->connector)) {
1415 ret = PTR_ERR(dp_display->connector);
1416 DRM_DEV_ERROR(dev->dev,
1417 "failed to create dp connector: %d\n", ret);
1418 dp_display->connector = NULL;
1422 priv->connectors[priv->num_connectors++] = dp_display->connector;
1426 int msm_dp_display_enable(struct msm_dp *dp, struct drm_encoder *encoder)
1429 struct dp_display_private *dp_display;
1432 dp_display = container_of(dp, struct dp_display_private, dp_display);
1433 if (!dp_display->dp_mode.drm_mode.clock) {
1434 DRM_ERROR("invalid params\n");
1438 mutex_lock(&dp_display->event_mutex);
1440 /* stop sentinel checking */
1441 dp_del_event(dp_display, EV_CONNECT_PENDING_TIMEOUT);
1443 rc = dp_display_set_mode(dp, &dp_display->dp_mode);
1445 DRM_ERROR("Failed to perform a mode set, rc=%d\n", rc);
1446 mutex_unlock(&dp_display->event_mutex);
1450 rc = dp_display_prepare(dp);
1452 DRM_ERROR("DP display prepare failed, rc=%d\n", rc);
1453 mutex_unlock(&dp_display->event_mutex);
1457 state = dp_display->hpd_state;
1459 if (state == ST_DISPLAY_OFF)
1460 dp_display_host_init(dp_display, true);
1462 dp_display_enable(dp_display, 0);
1464 rc = dp_display_post_enable(dp);
1466 DRM_ERROR("DP display post enable failed, rc=%d\n", rc);
1467 dp_display_disable(dp_display, 0);
1468 dp_display_unprepare(dp);
1471 /* manual kick off plug event to train link */
1472 if (state == ST_DISPLAY_OFF)
1473 dp_add_event(dp_display, EV_IRQ_HPD_INT, 0, 0);
1475 /* completed connection */
1476 dp_display->hpd_state = ST_CONNECTED;
1478 mutex_unlock(&dp_display->event_mutex);
1483 int msm_dp_display_pre_disable(struct msm_dp *dp, struct drm_encoder *encoder)
1485 struct dp_display_private *dp_display;
1487 dp_display = container_of(dp, struct dp_display_private, dp_display);
1489 dp_ctrl_push_idle(dp_display->ctrl);
1494 int msm_dp_display_disable(struct msm_dp *dp, struct drm_encoder *encoder)
1498 struct dp_display_private *dp_display;
1500 dp_display = container_of(dp, struct dp_display_private, dp_display);
1502 mutex_lock(&dp_display->event_mutex);
1504 /* stop sentinel checking */
1505 dp_del_event(dp_display, EV_DISCONNECT_PENDING_TIMEOUT);
1507 dp_display_disable(dp_display, 0);
1509 rc = dp_display_unprepare(dp);
1511 DRM_ERROR("DP display unprepare failed, rc=%d\n", rc);
1513 state = dp_display->hpd_state;
1514 if (state == ST_DISCONNECT_PENDING) {
1515 /* completed disconnection */
1516 dp_display->hpd_state = ST_DISCONNECTED;
1518 dp_display->hpd_state = ST_DISPLAY_OFF;
1521 mutex_unlock(&dp_display->event_mutex);
1525 void msm_dp_display_mode_set(struct msm_dp *dp, struct drm_encoder *encoder,
1526 struct drm_display_mode *mode,
1527 struct drm_display_mode *adjusted_mode)
1529 struct dp_display_private *dp_display;
1531 dp_display = container_of(dp, struct dp_display_private, dp_display);
1533 memset(&dp_display->dp_mode, 0x0, sizeof(struct dp_display_mode));
1535 if (dp_display_check_video_test(dp))
1536 dp_display->dp_mode.bpp = dp_display_get_test_bpp(dp);
1537 else /* Default num_components per pixel = 3 */
1538 dp_display->dp_mode.bpp = dp->connector->display_info.bpc * 3;
1540 if (!dp_display->dp_mode.bpp)
1541 dp_display->dp_mode.bpp = 24; /* Default bpp */
1543 drm_mode_copy(&dp_display->dp_mode.drm_mode, adjusted_mode);
1545 dp_display->dp_mode.v_active_low =
1546 !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NVSYNC);
1548 dp_display->dp_mode.h_active_low =
1549 !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NHSYNC);