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