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