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 enum drm_mode_status 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 struct msm_dsi_pll *src_pll;
547 bool is_dual_dsi = IS_DUAL_DSI();
552 if (!msm_dsi_device_connected(msm_dsi))
556 * Do nothing with the host if it is DSI 1 in case of dual DSI.
557 * It is safe to call dsi_mgr_phy_disable() here because a single PHY
558 * won't be diabled until both PHYs request disable.
560 if (is_dual_dsi && (DSI_1 == id))
564 ret = drm_panel_disable(panel);
566 pr_err("%s: Panel %d OFF failed, %d\n", __func__, id,
570 ret = msm_dsi_host_disable(host);
572 pr_err("%s: host %d disable failed, %d\n", __func__, id, ret);
574 if (is_dual_dsi && msm_dsi1) {
575 ret = msm_dsi_host_disable(msm_dsi1->host);
577 pr_err("%s: host1 disable failed, %d\n", __func__, ret);
581 ret = drm_panel_unprepare(panel);
583 pr_err("%s: Panel %d unprepare failed,%d\n", __func__,
587 /* Save PLL status if it is a clock source */
588 src_pll = msm_dsi_phy_get_pll(msm_dsi->phy);
589 msm_dsi_pll_save_state(src_pll);
591 ret = msm_dsi_host_power_off(host);
593 pr_err("%s: host %d power off failed,%d\n", __func__, id, ret);
595 if (is_dual_dsi && msm_dsi1) {
596 ret = msm_dsi_host_power_off(msm_dsi1->host);
598 pr_err("%s: host1 power off failed, %d\n",
603 dsi_mgr_phy_disable(id);
606 static void dsi_mgr_bridge_mode_set(struct drm_bridge *bridge,
607 struct drm_display_mode *mode,
608 struct drm_display_mode *adjusted_mode)
610 int id = dsi_mgr_bridge_get_id(bridge);
611 struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
612 struct msm_dsi *other_dsi = dsi_mgr_get_other_dsi(id);
613 struct mipi_dsi_host *host = msm_dsi->host;
614 bool is_dual_dsi = IS_DUAL_DSI();
616 DBG("set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x",
617 mode->base.id, mode->name,
618 mode->vrefresh, mode->clock,
619 mode->hdisplay, mode->hsync_start,
620 mode->hsync_end, mode->htotal,
621 mode->vdisplay, mode->vsync_start,
622 mode->vsync_end, mode->vtotal,
623 mode->type, mode->flags);
625 if (is_dual_dsi && (DSI_1 == id))
628 msm_dsi_host_set_display_mode(host, adjusted_mode);
629 if (is_dual_dsi && other_dsi)
630 msm_dsi_host_set_display_mode(other_dsi->host, adjusted_mode);
633 static const struct drm_connector_funcs dsi_mgr_connector_funcs = {
634 .detect = dsi_mgr_connector_detect,
635 .fill_modes = drm_helper_probe_single_connector_modes,
636 .destroy = dsi_mgr_connector_destroy,
637 .reset = drm_atomic_helper_connector_reset,
638 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
639 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
642 static const struct drm_connector_helper_funcs dsi_mgr_conn_helper_funcs = {
643 .get_modes = dsi_mgr_connector_get_modes,
644 .mode_valid = dsi_mgr_connector_mode_valid,
645 .best_encoder = dsi_mgr_connector_best_encoder,
648 static const struct drm_bridge_funcs dsi_mgr_bridge_funcs = {
649 .pre_enable = dsi_mgr_bridge_pre_enable,
650 .enable = dsi_mgr_bridge_enable,
651 .disable = dsi_mgr_bridge_disable,
652 .post_disable = dsi_mgr_bridge_post_disable,
653 .mode_set = dsi_mgr_bridge_mode_set,
656 /* initialize connector when we're connected to a drm_panel */
657 struct drm_connector *msm_dsi_manager_connector_init(u8 id)
659 struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
660 struct drm_connector *connector = NULL;
661 struct dsi_connector *dsi_connector;
664 dsi_connector = kzalloc(sizeof(*dsi_connector), GFP_KERNEL);
666 return ERR_PTR(-ENOMEM);
668 dsi_connector->id = id;
670 connector = &dsi_connector->base;
672 ret = drm_connector_init(msm_dsi->dev, connector,
673 &dsi_mgr_connector_funcs, DRM_MODE_CONNECTOR_DSI);
677 drm_connector_helper_add(connector, &dsi_mgr_conn_helper_funcs);
679 /* Enable HPD to let hpd event is handled
680 * when panel is attached to the host.
682 connector->polled = DRM_CONNECTOR_POLL_HPD;
684 /* Display driver doesn't support interlace now. */
685 connector->interlace_allowed = 0;
686 connector->doublescan_allowed = 0;
688 drm_mode_connector_attach_encoder(connector, msm_dsi->encoder);
693 /* initialize bridge */
694 struct drm_bridge *msm_dsi_manager_bridge_init(u8 id)
696 struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
697 struct drm_bridge *bridge = NULL;
698 struct dsi_bridge *dsi_bridge;
699 struct drm_encoder *encoder;
702 dsi_bridge = devm_kzalloc(msm_dsi->dev->dev,
703 sizeof(*dsi_bridge), GFP_KERNEL);
711 encoder = msm_dsi->encoder;
713 bridge = &dsi_bridge->base;
714 bridge->funcs = &dsi_mgr_bridge_funcs;
716 ret = drm_bridge_attach(encoder, bridge, NULL);
724 msm_dsi_manager_bridge_destroy(bridge);
729 struct drm_connector *msm_dsi_manager_ext_bridge_init(u8 id)
731 struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
732 struct drm_device *dev = msm_dsi->dev;
733 struct drm_encoder *encoder;
734 struct drm_bridge *int_bridge, *ext_bridge;
735 struct drm_connector *connector;
736 struct list_head *connector_list;
738 int_bridge = msm_dsi->bridge;
739 ext_bridge = msm_dsi->external_bridge =
740 msm_dsi_host_get_bridge(msm_dsi->host);
742 encoder = msm_dsi->encoder;
744 /* link the internal dsi bridge to the external bridge */
745 drm_bridge_attach(encoder, ext_bridge, int_bridge);
748 * we need the drm_connector created by the external bridge
749 * driver (or someone else) to feed it to our driver's
750 * priv->connector[] list, mainly for msm_fbdev_init()
752 connector_list = &dev->mode_config.connector_list;
754 list_for_each_entry(connector, connector_list, head) {
757 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
758 if (connector->encoder_ids[i] == encoder->base.id)
763 return ERR_PTR(-ENODEV);
766 void msm_dsi_manager_bridge_destroy(struct drm_bridge *bridge)
770 int msm_dsi_manager_cmd_xfer(int id, const struct mipi_dsi_msg *msg)
772 struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
773 struct msm_dsi *msm_dsi0 = dsi_mgr_get_dsi(DSI_0);
774 struct mipi_dsi_host *host = msm_dsi->host;
775 bool is_read = (msg->rx_buf && msg->rx_len);
776 bool need_sync = (IS_SYNC_NEEDED() && !is_read);
779 if (!msg->tx_buf || !msg->tx_len)
782 /* In dual master case, panel requires the same commands sent to
783 * both DSI links. Host issues the command trigger to both links
784 * when DSI_1 calls the cmd transfer function, no matter it happens
785 * before or after DSI_0 cmd transfer.
787 if (need_sync && (id == DSI_0))
788 return is_read ? msg->rx_len : msg->tx_len;
790 if (need_sync && msm_dsi0) {
791 ret = msm_dsi_host_xfer_prepare(msm_dsi0->host, msg);
793 pr_err("%s: failed to prepare non-trigger host, %d\n",
798 ret = msm_dsi_host_xfer_prepare(host, msg);
800 pr_err("%s: failed to prepare host, %d\n", __func__, ret);
804 ret = is_read ? msm_dsi_host_cmd_rx(host, msg) :
805 msm_dsi_host_cmd_tx(host, msg);
807 msm_dsi_host_xfer_restore(host, msg);
810 if (need_sync && msm_dsi0)
811 msm_dsi_host_xfer_restore(msm_dsi0->host, msg);
816 bool msm_dsi_manager_cmd_xfer_trigger(int id, u32 dma_base, u32 len)
818 struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
819 struct msm_dsi *msm_dsi0 = dsi_mgr_get_dsi(DSI_0);
820 struct mipi_dsi_host *host = msm_dsi->host;
822 if (IS_SYNC_NEEDED() && (id == DSI_0))
825 if (IS_SYNC_NEEDED() && msm_dsi0)
826 msm_dsi_host_cmd_xfer_commit(msm_dsi0->host, dma_base, len);
828 msm_dsi_host_cmd_xfer_commit(host, dma_base, len);
833 void msm_dsi_manager_attach_dsi_device(int id, u32 device_flags)
835 struct msm_dsi *msm_dsi = dsi_mgr_get_dsi(id);
836 struct drm_device *dev = msm_dsi->dev;
837 struct msm_drm_private *priv;
839 struct drm_encoder *encoder;
842 * drm_device pointer is assigned to msm_dsi only in the modeset_init
843 * path. If mipi_dsi_attach() happens in DSI driver's probe path
844 * (generally the case when we're connected to a drm_panel of the type
845 * mipi_dsi_device), this would be NULL. In such cases, try to set the
846 * encoder mode in the DSI connector's detect() op.
851 priv = dev->dev_private;
853 encoder = msm_dsi_get_encoder(msm_dsi);
855 if (encoder && kms->funcs->set_encoder_mode)
856 if (!(device_flags & MIPI_DSI_MODE_VIDEO))
857 kms->funcs->set_encoder_mode(kms, encoder, true);
860 int msm_dsi_manager_register(struct msm_dsi *msm_dsi)
862 struct msm_dsi_manager *msm_dsim = &msm_dsim_glb;
863 int id = msm_dsi->id;
867 pr_err("%s: invalid id %d\n", __func__, id);
871 if (msm_dsim->dsi[id]) {
872 pr_err("%s: dsi%d already registered\n", __func__, id);
876 msm_dsim->dsi[id] = msm_dsi;
878 ret = dsi_mgr_parse_dual_dsi(msm_dsi->pdev->dev.of_node, id);
880 pr_err("%s: failed to parse dual DSI info\n", __func__);
884 ret = dsi_mgr_setup_components(id);
886 pr_err("%s: failed to register mipi dsi host for DSI %d\n",
894 msm_dsim->dsi[id] = NULL;
898 void msm_dsi_manager_unregister(struct msm_dsi *msm_dsi)
900 struct msm_dsi_manager *msm_dsim = &msm_dsim_glb;
903 msm_dsi_host_unregister(msm_dsi->host);
904 msm_dsim->dsi[msm_dsi->id] = NULL;