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(msm_dsi->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;