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