2 * Copyright (c) 2015, The Linux Foundation. All rights reserved.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 and
6 * only version 2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
17 #define DSI_CLOCK_MASTER DSI_0
18 #define DSI_CLOCK_SLAVE DSI_1
20 #define DSI_LEFT DSI_0
21 #define DSI_RIGHT DSI_1
23 /* According to the current drm framework sequence, take the encoder of
24 * DSI_1 as master encoder
26 #define DSI_ENCODER_MASTER DSI_1
27 #define DSI_ENCODER_SLAVE DSI_0
29 struct msm_dsi_manager
{
30 struct msm_dsi
*dsi
[DSI_MAX
];
34 int master_dsi_link_id
;
37 static struct msm_dsi_manager msm_dsim_glb
;
39 #define IS_DUAL_DSI() (msm_dsim_glb.is_dual_dsi)
40 #define IS_SYNC_NEEDED() (msm_dsim_glb.is_sync_needed)
41 #define IS_MASTER_DSI_LINK(id) (msm_dsim_glb.master_dsi_link_id == id)
43 static inline struct msm_dsi
*dsi_mgr_get_dsi(int id
)
45 return msm_dsim_glb
.dsi
[id
];
48 static inline struct msm_dsi
*dsi_mgr_get_other_dsi(int id
)
50 return msm_dsim_glb
.dsi
[(id
+ 1) % DSI_MAX
];
53 static int dsi_mgr_parse_dual_dsi(struct device_node
*np
, int id
)
55 struct msm_dsi_manager
*msm_dsim
= &msm_dsim_glb
;
57 /* We assume 2 dsi nodes have the same information of dual-dsi and
58 * sync-mode, and only one node specifies master in case of dual mode.
60 if (!msm_dsim
->is_dual_dsi
)
61 msm_dsim
->is_dual_dsi
= of_property_read_bool(
62 np
, "qcom,dual-dsi-mode");
64 if (msm_dsim
->is_dual_dsi
) {
65 if (of_property_read_bool(np
, "qcom,master-dsi"))
66 msm_dsim
->master_dsi_link_id
= id
;
67 if (!msm_dsim
->is_sync_needed
)
68 msm_dsim
->is_sync_needed
= of_property_read_bool(
69 np
, "qcom,sync-dual-dsi");
75 static int dsi_mgr_setup_components(int id
)
77 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
78 struct msm_dsi
*other_dsi
= dsi_mgr_get_other_dsi(id
);
79 struct msm_dsi
*clk_master_dsi
= dsi_mgr_get_dsi(DSI_CLOCK_MASTER
);
80 struct msm_dsi
*clk_slave_dsi
= dsi_mgr_get_dsi(DSI_CLOCK_SLAVE
);
81 struct msm_dsi_pll
*src_pll
;
85 ret
= msm_dsi_host_register(msm_dsi
->host
, true);
89 msm_dsi_phy_set_usecase(msm_dsi
->phy
, MSM_DSI_PHY_STANDALONE
);
90 src_pll
= msm_dsi_phy_get_pll(msm_dsi
->phy
);
91 ret
= msm_dsi_host_set_src_pll(msm_dsi
->host
, src_pll
);
92 } else if (!other_dsi
) {
95 struct msm_dsi
*master_link_dsi
= IS_MASTER_DSI_LINK(id
) ?
97 struct msm_dsi
*slave_link_dsi
= IS_MASTER_DSI_LINK(id
) ?
99 /* Register slave host first, so that slave DSI device
100 * has a chance to probe, and do not block the master
101 * DSI device's probe.
102 * Also, do not check defer for the slave host,
103 * because only master DSI device adds the panel to global
104 * panel list. The panel's device is the master DSI device.
106 ret
= msm_dsi_host_register(slave_link_dsi
->host
, false);
109 ret
= msm_dsi_host_register(master_link_dsi
->host
, true);
113 /* PLL0 is to drive both 2 DSI link clocks in Dual DSI mode. */
114 msm_dsi_phy_set_usecase(clk_master_dsi
->phy
,
116 msm_dsi_phy_set_usecase(clk_slave_dsi
->phy
,
118 src_pll
= msm_dsi_phy_get_pll(clk_master_dsi
->phy
);
119 ret
= msm_dsi_host_set_src_pll(msm_dsi
->host
, src_pll
);
122 ret
= msm_dsi_host_set_src_pll(other_dsi
->host
, src_pll
);
128 static int enable_phy(struct msm_dsi
*msm_dsi
, int src_pll_id
,
129 struct msm_dsi_phy_shared_timings
*shared_timings
)
131 struct msm_dsi_phy_clk_request clk_req
;
134 msm_dsi_host_get_phy_clk_req(msm_dsi
->host
, &clk_req
);
136 ret
= msm_dsi_phy_enable(msm_dsi
->phy
, src_pll_id
, &clk_req
);
137 msm_dsi_phy_get_shared_timings(msm_dsi
->phy
, shared_timings
);
143 dsi_mgr_phy_enable(int id
,
144 struct msm_dsi_phy_shared_timings shared_timings
[DSI_MAX
])
146 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
147 struct msm_dsi
*mdsi
= dsi_mgr_get_dsi(DSI_CLOCK_MASTER
);
148 struct msm_dsi
*sdsi
= dsi_mgr_get_dsi(DSI_CLOCK_SLAVE
);
149 int src_pll_id
= IS_DUAL_DSI() ? DSI_CLOCK_MASTER
: id
;
152 /* In case of dual DSI, some registers in PHY1 have been programmed
153 * during PLL0 clock's set_rate. The PHY1 reset called by host1 here
154 * will silently reset those PHY1 registers. Therefore we need to reset
155 * and enable both PHYs before any PLL clock operation.
157 if (IS_DUAL_DSI() && mdsi
&& sdsi
) {
158 if (!mdsi
->phy_enabled
&& !sdsi
->phy_enabled
) {
159 msm_dsi_host_reset_phy(mdsi
->host
);
160 msm_dsi_host_reset_phy(sdsi
->host
);
162 ret
= enable_phy(mdsi
, src_pll_id
,
163 &shared_timings
[DSI_CLOCK_MASTER
]);
166 ret
= enable_phy(sdsi
, src_pll_id
,
167 &shared_timings
[DSI_CLOCK_SLAVE
]);
169 msm_dsi_phy_disable(mdsi
->phy
);
174 msm_dsi_host_reset_phy(mdsi
->host
);
175 ret
= enable_phy(msm_dsi
, src_pll_id
, &shared_timings
[id
]);
180 msm_dsi
->phy_enabled
= true;
185 static void dsi_mgr_phy_disable(int id
)
187 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
188 struct msm_dsi
*mdsi
= dsi_mgr_get_dsi(DSI_CLOCK_MASTER
);
189 struct msm_dsi
*sdsi
= dsi_mgr_get_dsi(DSI_CLOCK_SLAVE
);
192 * In dual-dsi configuration, the phy should be disabled for the
193 * first controller only when the second controller is disabled.
195 msm_dsi
->phy_enabled
= false;
196 if (IS_DUAL_DSI() && mdsi
&& sdsi
) {
197 if (!mdsi
->phy_enabled
&& !sdsi
->phy_enabled
) {
198 msm_dsi_phy_disable(sdsi
->phy
);
199 msm_dsi_phy_disable(mdsi
->phy
);
202 msm_dsi_phy_disable(msm_dsi
->phy
);
206 struct dsi_connector
{
207 struct drm_connector base
;
212 struct drm_bridge base
;
216 #define to_dsi_connector(x) container_of(x, struct dsi_connector, base)
217 #define to_dsi_bridge(x) container_of(x, struct dsi_bridge, base)
219 static inline int dsi_mgr_connector_get_id(struct drm_connector
*connector
)
221 struct dsi_connector
*dsi_connector
= to_dsi_connector(connector
);
222 return dsi_connector
->id
;
225 static int dsi_mgr_bridge_get_id(struct drm_bridge
*bridge
)
227 struct dsi_bridge
*dsi_bridge
= to_dsi_bridge(bridge
);
228 return dsi_bridge
->id
;
231 static enum drm_connector_status
dsi_mgr_connector_detect(
232 struct drm_connector
*connector
, bool force
)
234 int id
= dsi_mgr_connector_get_id(connector
);
235 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
236 struct msm_dsi
*other_dsi
= dsi_mgr_get_other_dsi(id
);
237 struct msm_drm_private
*priv
= connector
->dev
->dev_private
;
238 struct msm_kms
*kms
= priv
->kms
;
241 if (!msm_dsi
->panel
) {
242 msm_dsi
->panel
= msm_dsi_host_get_panel(msm_dsi
->host
,
243 &msm_dsi
->device_flags
);
245 /* There is only 1 panel in the global panel list
246 * for dual DSI mode. Therefore slave dsi should get
247 * the drm_panel instance from master dsi, and
248 * keep using the panel flags got from the current DSI link.
250 if (!msm_dsi
->panel
&& IS_DUAL_DSI() &&
251 !IS_MASTER_DSI_LINK(id
) && other_dsi
)
252 msm_dsi
->panel
= msm_dsi_host_get_panel(
253 other_dsi
->host
, NULL
);
256 if (msm_dsi
->panel
&& kms
->funcs
->set_encoder_mode
) {
257 bool cmd_mode
= !(msm_dsi
->device_flags
&
258 MIPI_DSI_MODE_VIDEO
);
259 struct drm_encoder
*encoder
=
260 msm_dsi_get_encoder(msm_dsi
);
262 kms
->funcs
->set_encoder_mode(kms
, encoder
, cmd_mode
);
265 if (msm_dsi
->panel
&& IS_DUAL_DSI())
266 drm_object_attach_property(&connector
->base
,
267 connector
->dev
->mode_config
.tile_property
, 0);
269 /* Set split display info to kms once dual DSI panel is
270 * connected to both hosts.
272 if (msm_dsi
->panel
&& IS_DUAL_DSI() &&
273 other_dsi
&& other_dsi
->panel
) {
274 bool cmd_mode
= !(msm_dsi
->device_flags
&
275 MIPI_DSI_MODE_VIDEO
);
276 struct drm_encoder
*encoder
= msm_dsi_get_encoder(
277 dsi_mgr_get_dsi(DSI_ENCODER_MASTER
));
278 struct drm_encoder
*slave_enc
= msm_dsi_get_encoder(
279 dsi_mgr_get_dsi(DSI_ENCODER_SLAVE
));
281 if (kms
->funcs
->set_split_display
)
282 kms
->funcs
->set_split_display(kms
, encoder
,
283 slave_enc
, cmd_mode
);
285 pr_err("mdp does not support dual DSI\n");
289 return msm_dsi
->panel
? connector_status_connected
:
290 connector_status_disconnected
;
293 static void dsi_mgr_connector_destroy(struct drm_connector
*connector
)
295 struct dsi_connector
*dsi_connector
= to_dsi_connector(connector
);
299 drm_connector_cleanup(connector
);
301 kfree(dsi_connector
);
304 static void dsi_dual_connector_fix_modes(struct drm_connector
*connector
)
306 struct drm_display_mode
*mode
, *m
;
308 /* Only support left-right mode */
309 list_for_each_entry_safe(mode
, m
, &connector
->probed_modes
, head
) {
311 mode
->hdisplay
>>= 1;
312 mode
->hsync_start
>>= 1;
313 mode
->hsync_end
>>= 1;
315 drm_mode_set_name(mode
);
319 static int dsi_dual_connector_tile_init(
320 struct drm_connector
*connector
, int id
)
322 struct drm_display_mode
*mode
;
323 /* Fake topology id */
324 char topo_id
[8] = {'M', 'S', 'M', 'D', 'U', 'D', 'S', 'I'};
326 if (connector
->tile_group
) {
327 DBG("Tile property has been initialized");
331 /* Use the first mode only for now */
332 mode
= list_first_entry(&connector
->probed_modes
,
333 struct drm_display_mode
,
338 connector
->tile_group
= drm_mode_get_tile_group(
339 connector
->dev
, topo_id
);
340 if (!connector
->tile_group
)
341 connector
->tile_group
= drm_mode_create_tile_group(
342 connector
->dev
, topo_id
);
343 if (!connector
->tile_group
) {
344 pr_err("%s: failed to create tile group\n", __func__
);
348 connector
->has_tile
= true;
349 connector
->tile_is_single_monitor
= true;
351 /* mode has been fixed */
352 connector
->tile_h_size
= mode
->hdisplay
;
353 connector
->tile_v_size
= mode
->vdisplay
;
355 /* Only support left-right mode */
356 connector
->num_h_tile
= 2;
357 connector
->num_v_tile
= 1;
359 connector
->tile_v_loc
= 0;
360 connector
->tile_h_loc
= (id
== DSI_RIGHT
) ? 1 : 0;
365 static int dsi_mgr_connector_get_modes(struct drm_connector
*connector
)
367 int id
= dsi_mgr_connector_get_id(connector
);
368 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
369 struct drm_panel
*panel
= msm_dsi
->panel
;
375 /* Since we have 2 connectors, but only 1 drm_panel in dual DSI mode,
376 * panel should not attach to any connector.
377 * Only temporarily attach panel to the current connector here,
378 * to let panel set mode to this connector.
380 drm_panel_attach(panel
, connector
);
381 num
= drm_panel_get_modes(panel
);
382 drm_panel_detach(panel
);
387 /* report half resolution to user */
388 dsi_dual_connector_fix_modes(connector
);
389 ret
= dsi_dual_connector_tile_init(connector
, id
);
392 ret
= drm_mode_connector_set_tile_property(connector
);
394 pr_err("%s: set tile property failed, %d\n",
403 static int dsi_mgr_connector_mode_valid(struct drm_connector
*connector
,
404 struct drm_display_mode
*mode
)
406 int id
= dsi_mgr_connector_get_id(connector
);
407 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
408 struct drm_encoder
*encoder
= msm_dsi_get_encoder(msm_dsi
);
409 struct msm_drm_private
*priv
= connector
->dev
->dev_private
;
410 struct msm_kms
*kms
= priv
->kms
;
411 long actual
, requested
;
414 requested
= 1000 * mode
->clock
;
415 actual
= kms
->funcs
->round_pixclk(kms
, requested
, encoder
);
417 DBG("requested=%ld, actual=%ld", requested
, actual
);
418 if (actual
!= requested
)
419 return MODE_CLOCK_RANGE
;
424 static struct drm_encoder
*
425 dsi_mgr_connector_best_encoder(struct drm_connector
*connector
)
427 int id
= dsi_mgr_connector_get_id(connector
);
428 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
431 return msm_dsi_get_encoder(msm_dsi
);
434 static void dsi_mgr_bridge_pre_enable(struct drm_bridge
*bridge
)
436 int id
= dsi_mgr_bridge_get_id(bridge
);
437 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
438 struct msm_dsi
*msm_dsi1
= dsi_mgr_get_dsi(DSI_1
);
439 struct mipi_dsi_host
*host
= msm_dsi
->host
;
440 struct drm_panel
*panel
= msm_dsi
->panel
;
441 struct msm_dsi_phy_shared_timings phy_shared_timings
[DSI_MAX
];
442 bool is_dual_dsi
= IS_DUAL_DSI();
446 if (!msm_dsi_device_connected(msm_dsi
))
449 ret
= dsi_mgr_phy_enable(id
, phy_shared_timings
);
453 /* Do nothing with the host if it is DSI 1 in case of dual DSI */
454 if (is_dual_dsi
&& (DSI_1
== id
))
457 ret
= msm_dsi_host_power_on(host
, &phy_shared_timings
[id
]);
459 pr_err("%s: power on host %d failed, %d\n", __func__
, id
, ret
);
463 if (is_dual_dsi
&& msm_dsi1
) {
464 ret
= msm_dsi_host_power_on(msm_dsi1
->host
,
465 &phy_shared_timings
[DSI_1
]);
467 pr_err("%s: power on host1 failed, %d\n",
473 /* Always call panel functions once, because even for dual panels,
474 * there is only one drm_panel instance.
477 ret
= drm_panel_prepare(panel
);
479 pr_err("%s: prepare panel %d failed, %d\n", __func__
,
481 goto panel_prep_fail
;
485 ret
= msm_dsi_host_enable(host
);
487 pr_err("%s: enable host %d failed, %d\n", __func__
, id
, ret
);
491 if (is_dual_dsi
&& msm_dsi1
) {
492 ret
= msm_dsi_host_enable(msm_dsi1
->host
);
494 pr_err("%s: enable host1 failed, %d\n", __func__
, ret
);
500 ret
= drm_panel_enable(panel
);
502 pr_err("%s: enable panel %d failed, %d\n", __func__
, id
,
511 if (is_dual_dsi
&& msm_dsi1
)
512 msm_dsi_host_disable(msm_dsi1
->host
);
514 msm_dsi_host_disable(host
);
517 drm_panel_unprepare(panel
);
519 if (is_dual_dsi
&& msm_dsi1
)
520 msm_dsi_host_power_off(msm_dsi1
->host
);
522 msm_dsi_host_power_off(host
);
524 dsi_mgr_phy_disable(id
);
529 static void dsi_mgr_bridge_enable(struct drm_bridge
*bridge
)
534 static void dsi_mgr_bridge_disable(struct drm_bridge
*bridge
)
539 static void dsi_mgr_bridge_post_disable(struct drm_bridge
*bridge
)
541 int id
= dsi_mgr_bridge_get_id(bridge
);
542 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
543 struct msm_dsi
*msm_dsi1
= dsi_mgr_get_dsi(DSI_1
);
544 struct mipi_dsi_host
*host
= msm_dsi
->host
;
545 struct drm_panel
*panel
= msm_dsi
->panel
;
546 bool is_dual_dsi
= IS_DUAL_DSI();
551 if (!msm_dsi_device_connected(msm_dsi
))
555 * Do nothing with the host if it is DSI 1 in case of dual DSI.
556 * It is safe to call dsi_mgr_phy_disable() here because a single PHY
557 * won't be diabled until both PHYs request disable.
559 if (is_dual_dsi
&& (DSI_1
== id
))
563 ret
= drm_panel_disable(panel
);
565 pr_err("%s: Panel %d OFF failed, %d\n", __func__
, id
,
569 ret
= msm_dsi_host_disable(host
);
571 pr_err("%s: host %d disable failed, %d\n", __func__
, id
, ret
);
573 if (is_dual_dsi
&& msm_dsi1
) {
574 ret
= msm_dsi_host_disable(msm_dsi1
->host
);
576 pr_err("%s: host1 disable failed, %d\n", __func__
, ret
);
580 ret
= drm_panel_unprepare(panel
);
582 pr_err("%s: Panel %d unprepare failed,%d\n", __func__
,
586 ret
= msm_dsi_host_power_off(host
);
588 pr_err("%s: host %d power off failed,%d\n", __func__
, id
, ret
);
590 if (is_dual_dsi
&& msm_dsi1
) {
591 ret
= msm_dsi_host_power_off(msm_dsi1
->host
);
593 pr_err("%s: host1 power off failed, %d\n",
598 dsi_mgr_phy_disable(id
);
601 static void dsi_mgr_bridge_mode_set(struct drm_bridge
*bridge
,
602 struct drm_display_mode
*mode
,
603 struct drm_display_mode
*adjusted_mode
)
605 int id
= dsi_mgr_bridge_get_id(bridge
);
606 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
607 struct msm_dsi
*other_dsi
= dsi_mgr_get_other_dsi(id
);
608 struct mipi_dsi_host
*host
= msm_dsi
->host
;
609 bool is_dual_dsi
= IS_DUAL_DSI();
611 DBG("set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",
612 mode
->base
.id
, mode
->name
,
613 mode
->vrefresh
, mode
->clock
,
614 mode
->hdisplay
, mode
->hsync_start
,
615 mode
->hsync_end
, mode
->htotal
,
616 mode
->vdisplay
, mode
->vsync_start
,
617 mode
->vsync_end
, mode
->vtotal
,
618 mode
->type
, mode
->flags
);
620 if (is_dual_dsi
&& (DSI_1
== id
))
623 msm_dsi_host_set_display_mode(host
, adjusted_mode
);
624 if (is_dual_dsi
&& other_dsi
)
625 msm_dsi_host_set_display_mode(other_dsi
->host
, adjusted_mode
);
628 static const struct drm_connector_funcs dsi_mgr_connector_funcs
= {
629 .dpms
= drm_atomic_helper_connector_dpms
,
630 .detect
= dsi_mgr_connector_detect
,
631 .fill_modes
= drm_helper_probe_single_connector_modes
,
632 .destroy
= dsi_mgr_connector_destroy
,
633 .reset
= drm_atomic_helper_connector_reset
,
634 .atomic_duplicate_state
= drm_atomic_helper_connector_duplicate_state
,
635 .atomic_destroy_state
= drm_atomic_helper_connector_destroy_state
,
638 static const struct drm_connector_helper_funcs dsi_mgr_conn_helper_funcs
= {
639 .get_modes
= dsi_mgr_connector_get_modes
,
640 .mode_valid
= dsi_mgr_connector_mode_valid
,
641 .best_encoder
= dsi_mgr_connector_best_encoder
,
644 static const struct drm_bridge_funcs dsi_mgr_bridge_funcs
= {
645 .pre_enable
= dsi_mgr_bridge_pre_enable
,
646 .enable
= dsi_mgr_bridge_enable
,
647 .disable
= dsi_mgr_bridge_disable
,
648 .post_disable
= dsi_mgr_bridge_post_disable
,
649 .mode_set
= dsi_mgr_bridge_mode_set
,
652 /* initialize connector when we're connected to a drm_panel */
653 struct drm_connector
*msm_dsi_manager_connector_init(u8 id
)
655 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
656 struct drm_connector
*connector
= NULL
;
657 struct dsi_connector
*dsi_connector
;
660 dsi_connector
= kzalloc(sizeof(*dsi_connector
), GFP_KERNEL
);
662 return ERR_PTR(-ENOMEM
);
664 dsi_connector
->id
= id
;
666 connector
= &dsi_connector
->base
;
668 ret
= drm_connector_init(msm_dsi
->dev
, connector
,
669 &dsi_mgr_connector_funcs
, DRM_MODE_CONNECTOR_DSI
);
673 drm_connector_helper_add(connector
, &dsi_mgr_conn_helper_funcs
);
675 /* Enable HPD to let hpd event is handled
676 * when panel is attached to the host.
678 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
680 /* Display driver doesn't support interlace now. */
681 connector
->interlace_allowed
= 0;
682 connector
->doublescan_allowed
= 0;
684 drm_mode_connector_attach_encoder(connector
, msm_dsi
->encoder
);
689 /* initialize bridge */
690 struct drm_bridge
*msm_dsi_manager_bridge_init(u8 id
)
692 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
693 struct drm_bridge
*bridge
= NULL
;
694 struct dsi_bridge
*dsi_bridge
;
695 struct drm_encoder
*encoder
;
698 dsi_bridge
= devm_kzalloc(msm_dsi
->dev
->dev
,
699 sizeof(*dsi_bridge
), GFP_KERNEL
);
707 encoder
= msm_dsi
->encoder
;
709 bridge
= &dsi_bridge
->base
;
710 bridge
->funcs
= &dsi_mgr_bridge_funcs
;
712 ret
= drm_bridge_attach(encoder
, bridge
, NULL
);
720 msm_dsi_manager_bridge_destroy(bridge
);
725 struct drm_connector
*msm_dsi_manager_ext_bridge_init(u8 id
)
727 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
728 struct drm_device
*dev
= msm_dsi
->dev
;
729 struct drm_encoder
*encoder
;
730 struct drm_bridge
*int_bridge
, *ext_bridge
;
731 struct drm_connector
*connector
;
732 struct list_head
*connector_list
;
734 int_bridge
= msm_dsi
->bridge
;
735 ext_bridge
= msm_dsi
->external_bridge
=
736 msm_dsi_host_get_bridge(msm_dsi
->host
);
738 encoder
= msm_dsi
->encoder
;
740 /* link the internal dsi bridge to the external bridge */
741 drm_bridge_attach(encoder
, ext_bridge
, int_bridge
);
744 * we need the drm_connector created by the external bridge
745 * driver (or someone else) to feed it to our driver's
746 * priv->connector[] list, mainly for msm_fbdev_init()
748 connector_list
= &dev
->mode_config
.connector_list
;
750 list_for_each_entry(connector
, connector_list
, head
) {
753 for (i
= 0; i
< DRM_CONNECTOR_MAX_ENCODER
; i
++) {
754 if (connector
->encoder_ids
[i
] == encoder
->base
.id
)
759 return ERR_PTR(-ENODEV
);
762 void msm_dsi_manager_bridge_destroy(struct drm_bridge
*bridge
)
766 int msm_dsi_manager_cmd_xfer(int id
, const struct mipi_dsi_msg
*msg
)
768 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
769 struct msm_dsi
*msm_dsi0
= dsi_mgr_get_dsi(DSI_0
);
770 struct mipi_dsi_host
*host
= msm_dsi
->host
;
771 bool is_read
= (msg
->rx_buf
&& msg
->rx_len
);
772 bool need_sync
= (IS_SYNC_NEEDED() && !is_read
);
775 if (!msg
->tx_buf
|| !msg
->tx_len
)
778 /* In dual master case, panel requires the same commands sent to
779 * both DSI links. Host issues the command trigger to both links
780 * when DSI_1 calls the cmd transfer function, no matter it happens
781 * before or after DSI_0 cmd transfer.
783 if (need_sync
&& (id
== DSI_0
))
784 return is_read
? msg
->rx_len
: msg
->tx_len
;
786 if (need_sync
&& msm_dsi0
) {
787 ret
= msm_dsi_host_xfer_prepare(msm_dsi0
->host
, msg
);
789 pr_err("%s: failed to prepare non-trigger host, %d\n",
794 ret
= msm_dsi_host_xfer_prepare(host
, msg
);
796 pr_err("%s: failed to prepare host, %d\n", __func__
, ret
);
800 ret
= is_read
? msm_dsi_host_cmd_rx(host
, msg
) :
801 msm_dsi_host_cmd_tx(host
, msg
);
803 msm_dsi_host_xfer_restore(host
, msg
);
806 if (need_sync
&& msm_dsi0
)
807 msm_dsi_host_xfer_restore(msm_dsi0
->host
, msg
);
812 bool msm_dsi_manager_cmd_xfer_trigger(int id
, u32 dma_base
, u32 len
)
814 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
815 struct msm_dsi
*msm_dsi0
= dsi_mgr_get_dsi(DSI_0
);
816 struct mipi_dsi_host
*host
= msm_dsi
->host
;
818 if (IS_SYNC_NEEDED() && (id
== DSI_0
))
821 if (IS_SYNC_NEEDED() && msm_dsi0
)
822 msm_dsi_host_cmd_xfer_commit(msm_dsi0
->host
, dma_base
, len
);
824 msm_dsi_host_cmd_xfer_commit(host
, dma_base
, len
);
829 void msm_dsi_manager_attach_dsi_device(int id
, u32 device_flags
)
831 struct msm_dsi
*msm_dsi
= dsi_mgr_get_dsi(id
);
832 struct drm_device
*dev
= msm_dsi
->dev
;
833 struct msm_drm_private
*priv
;
835 struct drm_encoder
*encoder
;
838 * drm_device pointer is assigned to msm_dsi only in the modeset_init
839 * path. If mipi_dsi_attach() happens in DSI driver's probe path
840 * (generally the case when we're connected to a drm_panel of the type
841 * mipi_dsi_device), this would be NULL. In such cases, try to set the
842 * encoder mode in the DSI connector's detect() op.
847 priv
= dev
->dev_private
;
849 encoder
= msm_dsi_get_encoder(msm_dsi
);
851 if (encoder
&& kms
->funcs
->set_encoder_mode
)
852 if (!(device_flags
& MIPI_DSI_MODE_VIDEO
))
853 kms
->funcs
->set_encoder_mode(kms
, encoder
, true);
856 int msm_dsi_manager_register(struct msm_dsi
*msm_dsi
)
858 struct msm_dsi_manager
*msm_dsim
= &msm_dsim_glb
;
859 int id
= msm_dsi
->id
;
863 pr_err("%s: invalid id %d\n", __func__
, id
);
867 if (msm_dsim
->dsi
[id
]) {
868 pr_err("%s: dsi%d already registered\n", __func__
, id
);
872 msm_dsim
->dsi
[id
] = msm_dsi
;
874 ret
= dsi_mgr_parse_dual_dsi(msm_dsi
->pdev
->dev
.of_node
, id
);
876 pr_err("%s: failed to parse dual DSI info\n", __func__
);
880 ret
= dsi_mgr_setup_components(id
);
882 pr_err("%s: failed to register mipi dsi host for DSI %d\n",
890 msm_dsim
->dsi
[id
] = NULL
;
894 void msm_dsi_manager_unregister(struct msm_dsi
*msm_dsi
)
896 struct msm_dsi_manager
*msm_dsim
= &msm_dsim_glb
;
899 msm_dsi_host_unregister(msm_dsi
->host
);
900 msm_dsim
->dsi
[msm_dsi
->id
] = NULL
;