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.
14 #include <linux/clk.h>
15 #include <linux/delay.h>
16 #include <linux/err.h>
17 #include <linux/gpio.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/interrupt.h>
20 #include <linux/of_device.h>
21 #include <linux/of_gpio.h>
22 #include <linux/of_irq.h>
23 #include <linux/pinctrl/consumer.h>
24 #include <linux/of_graph.h>
25 #include <linux/regulator/consumer.h>
26 #include <linux/spinlock.h>
27 #include <linux/mfd/syscon.h>
28 #include <linux/regmap.h>
29 #include <video/mipi_display.h>
36 static int dsi_get_version(const void __iomem
*base
, u32
*major
, u32
*minor
)
44 * From DSI6G(v3), addition of a 6G_HW_VERSION register at offset 0
45 * makes all other registers 4-byte shifted down.
47 * In order to identify between DSI6G(v3) and beyond, and DSIv2 and
48 * older, we read the DSI_VERSION register without any shift(offset
49 * 0x1f0). In the case of DSIv2, this hast to be a non-zero value. In
50 * the case of DSI6G, this has to be zero (the offset points to a
51 * scratch register which we never touch)
54 ver
= msm_readl(base
+ REG_DSI_VERSION
);
56 /* older dsi host, there is no register shift */
57 ver
= FIELD(ver
, DSI_VERSION_MAJOR
);
58 if (ver
<= MSM_DSI_VER_MAJOR_V2
) {
68 * newer host, offset 0 has 6G_HW_VERSION, the rest of the
69 * registers are shifted down, read DSI_VERSION again with
72 ver
= msm_readl(base
+ DSI_6G_REG_SHIFT
+ REG_DSI_VERSION
);
73 ver
= FIELD(ver
, DSI_VERSION_MAJOR
);
74 if (ver
== MSM_DSI_VER_MAJOR_6G
) {
77 *minor
= msm_readl(base
+ REG_DSI_6G_HW_VERSION
);
85 #define DSI_ERR_STATE_ACK 0x0000
86 #define DSI_ERR_STATE_TIMEOUT 0x0001
87 #define DSI_ERR_STATE_DLN0_PHY 0x0002
88 #define DSI_ERR_STATE_FIFO 0x0004
89 #define DSI_ERR_STATE_MDP_FIFO_UNDERFLOW 0x0008
90 #define DSI_ERR_STATE_INTERLEAVE_OP_CONTENTION 0x0010
91 #define DSI_ERR_STATE_PLL_UNLOCKED 0x0020
93 #define DSI_CLK_CTRL_ENABLE_CLKS \
94 (DSI_CLK_CTRL_AHBS_HCLK_ON | DSI_CLK_CTRL_AHBM_SCLK_ON | \
95 DSI_CLK_CTRL_PCLK_ON | DSI_CLK_CTRL_DSICLK_ON | \
96 DSI_CLK_CTRL_BYTECLK_ON | DSI_CLK_CTRL_ESCCLK_ON | \
97 DSI_CLK_CTRL_FORCE_ON_DYN_AHBM_HCLK)
100 struct mipi_dsi_host base
;
102 struct platform_device
*pdev
;
103 struct drm_device
*dev
;
107 void __iomem
*ctrl_base
;
108 struct regulator_bulk_data supplies
[DSI_DEV_REGULATOR_MAX
];
110 struct clk
*bus_clks
[DSI_BUS_CLK_MAX
];
112 struct clk
*byte_clk
;
114 struct clk
*pixel_clk
;
115 struct clk
*byte_clk_src
;
116 struct clk
*pixel_clk_src
;
121 /* DSI v2 specific clocks */
123 struct clk
*esc_clk_src
;
124 struct clk
*dsi_clk_src
;
128 struct gpio_desc
*disp_en_gpio
;
129 struct gpio_desc
*te_gpio
;
131 const struct msm_dsi_cfg_handler
*cfg_hnd
;
133 struct completion dma_comp
;
134 struct completion video_comp
;
135 struct mutex dev_mutex
;
136 struct mutex cmd_mutex
;
137 struct mutex clk_mutex
;
138 spinlock_t intr_lock
; /* Protect interrupt ctrl register */
141 struct work_struct err_work
;
142 struct work_struct hpd_work
;
143 struct workqueue_struct
*workqueue
;
145 /* DSI 6G TX buffer*/
146 struct drm_gem_object
*tx_gem_obj
;
148 /* DSI v2 TX buffer */
150 dma_addr_t tx_buf_paddr
;
158 struct drm_display_mode
*mode
;
160 /* connected device info */
161 struct device_node
*device_node
;
162 unsigned int channel
;
164 enum mipi_dsi_pixel_format format
;
165 unsigned long mode_flags
;
167 /* lane data parsed via DT */
171 u32 dma_cmd_ctrl_restore
;
178 static u32
dsi_get_bpp(const enum mipi_dsi_pixel_format fmt
)
181 case MIPI_DSI_FMT_RGB565
: return 16;
182 case MIPI_DSI_FMT_RGB666_PACKED
: return 18;
183 case MIPI_DSI_FMT_RGB666
:
184 case MIPI_DSI_FMT_RGB888
:
189 static inline u32
dsi_read(struct msm_dsi_host
*msm_host
, u32 reg
)
191 return msm_readl(msm_host
->ctrl_base
+ reg
);
193 static inline void dsi_write(struct msm_dsi_host
*msm_host
, u32 reg
, u32 data
)
195 msm_writel(data
, msm_host
->ctrl_base
+ reg
);
198 static int dsi_host_regulator_enable(struct msm_dsi_host
*msm_host
);
199 static void dsi_host_regulator_disable(struct msm_dsi_host
*msm_host
);
201 static const struct msm_dsi_cfg_handler
*dsi_get_config(
202 struct msm_dsi_host
*msm_host
)
204 const struct msm_dsi_cfg_handler
*cfg_hnd
= NULL
;
205 struct device
*dev
= &msm_host
->pdev
->dev
;
206 struct regulator
*gdsc_reg
;
209 u32 major
= 0, minor
= 0;
211 gdsc_reg
= regulator_get(dev
, "gdsc");
212 if (IS_ERR(gdsc_reg
)) {
213 pr_err("%s: cannot get gdsc\n", __func__
);
217 ahb_clk
= clk_get(dev
, "iface_clk");
218 if (IS_ERR(ahb_clk
)) {
219 pr_err("%s: cannot get interface clock\n", __func__
);
223 ret
= regulator_enable(gdsc_reg
);
225 pr_err("%s: unable to enable gdsc\n", __func__
);
229 ret
= clk_prepare_enable(ahb_clk
);
231 pr_err("%s: unable to enable ahb_clk\n", __func__
);
235 ret
= dsi_get_version(msm_host
->ctrl_base
, &major
, &minor
);
237 pr_err("%s: Invalid version\n", __func__
);
241 cfg_hnd
= msm_dsi_cfg_get(major
, minor
);
243 DBG("%s: Version %x:%x\n", __func__
, major
, minor
);
246 clk_disable_unprepare(ahb_clk
);
248 regulator_disable(gdsc_reg
);
252 regulator_put(gdsc_reg
);
257 static inline struct msm_dsi_host
*to_msm_dsi_host(struct mipi_dsi_host
*host
)
259 return container_of(host
, struct msm_dsi_host
, base
);
262 static void dsi_host_regulator_disable(struct msm_dsi_host
*msm_host
)
264 struct regulator_bulk_data
*s
= msm_host
->supplies
;
265 const struct dsi_reg_entry
*regs
= msm_host
->cfg_hnd
->cfg
->reg_cfg
.regs
;
266 int num
= msm_host
->cfg_hnd
->cfg
->reg_cfg
.num
;
270 for (i
= num
- 1; i
>= 0; i
--)
271 if (regs
[i
].disable_load
>= 0)
272 regulator_set_load(s
[i
].consumer
,
273 regs
[i
].disable_load
);
275 regulator_bulk_disable(num
, s
);
278 static int dsi_host_regulator_enable(struct msm_dsi_host
*msm_host
)
280 struct regulator_bulk_data
*s
= msm_host
->supplies
;
281 const struct dsi_reg_entry
*regs
= msm_host
->cfg_hnd
->cfg
->reg_cfg
.regs
;
282 int num
= msm_host
->cfg_hnd
->cfg
->reg_cfg
.num
;
286 for (i
= 0; i
< num
; i
++) {
287 if (regs
[i
].enable_load
>= 0) {
288 ret
= regulator_set_load(s
[i
].consumer
,
289 regs
[i
].enable_load
);
291 pr_err("regulator %d set op mode failed, %d\n",
298 ret
= regulator_bulk_enable(num
, s
);
300 pr_err("regulator enable failed, %d\n", ret
);
307 for (i
--; i
>= 0; i
--)
308 regulator_set_load(s
[i
].consumer
, regs
[i
].disable_load
);
312 static int dsi_regulator_init(struct msm_dsi_host
*msm_host
)
314 struct regulator_bulk_data
*s
= msm_host
->supplies
;
315 const struct dsi_reg_entry
*regs
= msm_host
->cfg_hnd
->cfg
->reg_cfg
.regs
;
316 int num
= msm_host
->cfg_hnd
->cfg
->reg_cfg
.num
;
319 for (i
= 0; i
< num
; i
++)
320 s
[i
].supply
= regs
[i
].name
;
322 ret
= devm_regulator_bulk_get(&msm_host
->pdev
->dev
, num
, s
);
324 pr_err("%s: failed to init regulator, ret=%d\n",
332 static int dsi_clk_init(struct msm_dsi_host
*msm_host
)
334 struct device
*dev
= &msm_host
->pdev
->dev
;
335 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
336 const struct msm_dsi_config
*cfg
= cfg_hnd
->cfg
;
340 for (i
= 0; i
< cfg
->num_bus_clks
; i
++) {
341 msm_host
->bus_clks
[i
] = devm_clk_get(dev
,
342 cfg
->bus_clk_names
[i
]);
343 if (IS_ERR(msm_host
->bus_clks
[i
])) {
344 ret
= PTR_ERR(msm_host
->bus_clks
[i
]);
345 pr_err("%s: Unable to get %s, ret = %d\n",
346 __func__
, cfg
->bus_clk_names
[i
], ret
);
351 /* get link and source clocks */
352 msm_host
->byte_clk
= devm_clk_get(dev
, "byte_clk");
353 if (IS_ERR(msm_host
->byte_clk
)) {
354 ret
= PTR_ERR(msm_host
->byte_clk
);
355 pr_err("%s: can't find dsi_byte_clk. ret=%d\n",
357 msm_host
->byte_clk
= NULL
;
361 msm_host
->pixel_clk
= devm_clk_get(dev
, "pixel_clk");
362 if (IS_ERR(msm_host
->pixel_clk
)) {
363 ret
= PTR_ERR(msm_host
->pixel_clk
);
364 pr_err("%s: can't find dsi_pixel_clk. ret=%d\n",
366 msm_host
->pixel_clk
= NULL
;
370 msm_host
->esc_clk
= devm_clk_get(dev
, "core_clk");
371 if (IS_ERR(msm_host
->esc_clk
)) {
372 ret
= PTR_ERR(msm_host
->esc_clk
);
373 pr_err("%s: can't find dsi_esc_clk. ret=%d\n",
375 msm_host
->esc_clk
= NULL
;
379 msm_host
->byte_clk_src
= clk_get_parent(msm_host
->byte_clk
);
380 if (!msm_host
->byte_clk_src
) {
382 pr_err("%s: can't find byte_clk_src. ret=%d\n", __func__
, ret
);
386 msm_host
->pixel_clk_src
= clk_get_parent(msm_host
->pixel_clk
);
387 if (!msm_host
->pixel_clk_src
) {
389 pr_err("%s: can't find pixel_clk_src. ret=%d\n", __func__
, ret
);
393 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_V2
) {
394 msm_host
->src_clk
= devm_clk_get(dev
, "src_clk");
395 if (IS_ERR(msm_host
->src_clk
)) {
396 ret
= PTR_ERR(msm_host
->src_clk
);
397 pr_err("%s: can't find dsi_src_clk. ret=%d\n",
399 msm_host
->src_clk
= NULL
;
403 msm_host
->esc_clk_src
= clk_get_parent(msm_host
->esc_clk
);
404 if (!msm_host
->esc_clk_src
) {
406 pr_err("%s: can't get esc_clk_src. ret=%d\n",
411 msm_host
->dsi_clk_src
= clk_get_parent(msm_host
->src_clk
);
412 if (!msm_host
->dsi_clk_src
) {
414 pr_err("%s: can't get dsi_clk_src. ret=%d\n",
422 static int dsi_bus_clk_enable(struct msm_dsi_host
*msm_host
)
424 const struct msm_dsi_config
*cfg
= msm_host
->cfg_hnd
->cfg
;
427 DBG("id=%d", msm_host
->id
);
429 for (i
= 0; i
< cfg
->num_bus_clks
; i
++) {
430 ret
= clk_prepare_enable(msm_host
->bus_clks
[i
]);
432 pr_err("%s: failed to enable bus clock %d ret %d\n",
441 clk_disable_unprepare(msm_host
->bus_clks
[i
]);
446 static void dsi_bus_clk_disable(struct msm_dsi_host
*msm_host
)
448 const struct msm_dsi_config
*cfg
= msm_host
->cfg_hnd
->cfg
;
453 for (i
= cfg
->num_bus_clks
- 1; i
>= 0; i
--)
454 clk_disable_unprepare(msm_host
->bus_clks
[i
]);
457 static int dsi_link_clk_enable_6g(struct msm_dsi_host
*msm_host
)
461 DBG("Set clk rates: pclk=%d, byteclk=%d",
462 msm_host
->mode
->clock
, msm_host
->byte_clk_rate
);
464 ret
= clk_set_rate(msm_host
->byte_clk
, msm_host
->byte_clk_rate
);
466 pr_err("%s: Failed to set rate byte clk, %d\n", __func__
, ret
);
470 ret
= clk_set_rate(msm_host
->pixel_clk
, msm_host
->mode
->clock
* 1000);
472 pr_err("%s: Failed to set rate pixel clk, %d\n", __func__
, ret
);
476 ret
= clk_prepare_enable(msm_host
->esc_clk
);
478 pr_err("%s: Failed to enable dsi esc clk\n", __func__
);
482 ret
= clk_prepare_enable(msm_host
->byte_clk
);
484 pr_err("%s: Failed to enable dsi byte clk\n", __func__
);
488 ret
= clk_prepare_enable(msm_host
->pixel_clk
);
490 pr_err("%s: Failed to enable dsi pixel clk\n", __func__
);
497 clk_disable_unprepare(msm_host
->byte_clk
);
499 clk_disable_unprepare(msm_host
->esc_clk
);
504 static int dsi_link_clk_enable_v2(struct msm_dsi_host
*msm_host
)
508 DBG("Set clk rates: pclk=%d, byteclk=%d, esc_clk=%d, dsi_src_clk=%d",
509 msm_host
->mode
->clock
, msm_host
->byte_clk_rate
,
510 msm_host
->esc_clk_rate
, msm_host
->src_clk_rate
);
512 ret
= clk_set_rate(msm_host
->byte_clk
, msm_host
->byte_clk_rate
);
514 pr_err("%s: Failed to set rate byte clk, %d\n", __func__
, ret
);
518 ret
= clk_set_rate(msm_host
->esc_clk
, msm_host
->esc_clk_rate
);
520 pr_err("%s: Failed to set rate esc clk, %d\n", __func__
, ret
);
524 ret
= clk_set_rate(msm_host
->src_clk
, msm_host
->src_clk_rate
);
526 pr_err("%s: Failed to set rate src clk, %d\n", __func__
, ret
);
530 ret
= clk_set_rate(msm_host
->pixel_clk
, msm_host
->mode
->clock
* 1000);
532 pr_err("%s: Failed to set rate pixel clk, %d\n", __func__
, ret
);
536 ret
= clk_prepare_enable(msm_host
->byte_clk
);
538 pr_err("%s: Failed to enable dsi byte clk\n", __func__
);
542 ret
= clk_prepare_enable(msm_host
->esc_clk
);
544 pr_err("%s: Failed to enable dsi esc clk\n", __func__
);
548 ret
= clk_prepare_enable(msm_host
->src_clk
);
550 pr_err("%s: Failed to enable dsi src clk\n", __func__
);
554 ret
= clk_prepare_enable(msm_host
->pixel_clk
);
556 pr_err("%s: Failed to enable dsi pixel clk\n", __func__
);
563 clk_disable_unprepare(msm_host
->src_clk
);
565 clk_disable_unprepare(msm_host
->esc_clk
);
567 clk_disable_unprepare(msm_host
->byte_clk
);
572 static int dsi_link_clk_enable(struct msm_dsi_host
*msm_host
)
574 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
576 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
)
577 return dsi_link_clk_enable_6g(msm_host
);
579 return dsi_link_clk_enable_v2(msm_host
);
582 static void dsi_link_clk_disable(struct msm_dsi_host
*msm_host
)
584 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
586 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
) {
587 clk_disable_unprepare(msm_host
->esc_clk
);
588 clk_disable_unprepare(msm_host
->pixel_clk
);
589 clk_disable_unprepare(msm_host
->byte_clk
);
591 clk_disable_unprepare(msm_host
->pixel_clk
);
592 clk_disable_unprepare(msm_host
->src_clk
);
593 clk_disable_unprepare(msm_host
->esc_clk
);
594 clk_disable_unprepare(msm_host
->byte_clk
);
598 static int dsi_clk_ctrl(struct msm_dsi_host
*msm_host
, bool enable
)
602 mutex_lock(&msm_host
->clk_mutex
);
604 ret
= dsi_bus_clk_enable(msm_host
);
606 pr_err("%s: Can not enable bus clk, %d\n",
610 ret
= dsi_link_clk_enable(msm_host
);
612 pr_err("%s: Can not enable link clk, %d\n",
614 dsi_bus_clk_disable(msm_host
);
618 dsi_link_clk_disable(msm_host
);
619 dsi_bus_clk_disable(msm_host
);
623 mutex_unlock(&msm_host
->clk_mutex
);
627 static int dsi_calc_clk_rate(struct msm_dsi_host
*msm_host
)
629 struct drm_display_mode
*mode
= msm_host
->mode
;
630 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
631 u8 lanes
= msm_host
->lanes
;
632 u32 bpp
= dsi_get_bpp(msm_host
->format
);
636 pr_err("%s: mode not set\n", __func__
);
640 pclk_rate
= mode
->clock
* 1000;
642 msm_host
->byte_clk_rate
= (pclk_rate
* bpp
) / (8 * lanes
);
644 pr_err("%s: forcing mdss_dsi lanes to 1\n", __func__
);
645 msm_host
->byte_clk_rate
= (pclk_rate
* bpp
) / 8;
648 DBG("pclk=%d, bclk=%d", pclk_rate
, msm_host
->byte_clk_rate
);
650 msm_host
->esc_clk_rate
= clk_get_rate(msm_host
->esc_clk
);
652 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_V2
) {
653 unsigned int esc_mhz
, esc_div
;
654 unsigned long byte_mhz
;
656 msm_host
->src_clk_rate
= (pclk_rate
* bpp
) / 8;
659 * esc clock is byte clock followed by a 4 bit divider,
660 * we need to find an escape clock frequency within the
661 * mipi DSI spec range within the maximum divider limit
662 * We iterate here between an escape clock frequencey
663 * between 20 Mhz to 5 Mhz and pick up the first one
664 * that can be supported by our divider
667 byte_mhz
= msm_host
->byte_clk_rate
/ 1000000;
669 for (esc_mhz
= 20; esc_mhz
>= 5; esc_mhz
--) {
670 esc_div
= DIV_ROUND_UP(byte_mhz
, esc_mhz
);
673 * TODO: Ideally, we shouldn't know what sort of divider
674 * is available in mmss_cc, we're just assuming that
675 * it'll always be a 4 bit divider. Need to come up with
678 if (esc_div
>= 1 && esc_div
<= 16)
685 msm_host
->esc_clk_rate
= msm_host
->byte_clk_rate
/ esc_div
;
687 DBG("esc=%d, src=%d", msm_host
->esc_clk_rate
,
688 msm_host
->src_clk_rate
);
694 static void dsi_phy_sw_reset(struct msm_dsi_host
*msm_host
)
697 dsi_write(msm_host
, REG_DSI_PHY_RESET
, DSI_PHY_RESET_RESET
);
698 /* Make sure fully reset */
701 dsi_write(msm_host
, REG_DSI_PHY_RESET
, 0);
705 static void dsi_intr_ctrl(struct msm_dsi_host
*msm_host
, u32 mask
, int enable
)
710 spin_lock_irqsave(&msm_host
->intr_lock
, flags
);
711 intr
= dsi_read(msm_host
, REG_DSI_INTR_CTRL
);
718 DBG("intr=%x enable=%d", intr
, enable
);
720 dsi_write(msm_host
, REG_DSI_INTR_CTRL
, intr
);
721 spin_unlock_irqrestore(&msm_host
->intr_lock
, flags
);
724 static inline enum dsi_traffic_mode
dsi_get_traffic_mode(const u32 mode_flags
)
726 if (mode_flags
& MIPI_DSI_MODE_VIDEO_BURST
)
728 else if (mode_flags
& MIPI_DSI_MODE_VIDEO_SYNC_PULSE
)
729 return NON_BURST_SYNCH_PULSE
;
731 return NON_BURST_SYNCH_EVENT
;
734 static inline enum dsi_vid_dst_format
dsi_get_vid_fmt(
735 const enum mipi_dsi_pixel_format mipi_fmt
)
738 case MIPI_DSI_FMT_RGB888
: return VID_DST_FORMAT_RGB888
;
739 case MIPI_DSI_FMT_RGB666
: return VID_DST_FORMAT_RGB666_LOOSE
;
740 case MIPI_DSI_FMT_RGB666_PACKED
: return VID_DST_FORMAT_RGB666
;
741 case MIPI_DSI_FMT_RGB565
: return VID_DST_FORMAT_RGB565
;
742 default: return VID_DST_FORMAT_RGB888
;
746 static inline enum dsi_cmd_dst_format
dsi_get_cmd_fmt(
747 const enum mipi_dsi_pixel_format mipi_fmt
)
750 case MIPI_DSI_FMT_RGB888
: return CMD_DST_FORMAT_RGB888
;
751 case MIPI_DSI_FMT_RGB666_PACKED
:
752 case MIPI_DSI_FMT_RGB666
: return VID_DST_FORMAT_RGB666
;
753 case MIPI_DSI_FMT_RGB565
: return CMD_DST_FORMAT_RGB565
;
754 default: return CMD_DST_FORMAT_RGB888
;
758 static void dsi_ctrl_config(struct msm_dsi_host
*msm_host
, bool enable
,
759 u32 clk_pre
, u32 clk_post
)
761 u32 flags
= msm_host
->mode_flags
;
762 enum mipi_dsi_pixel_format mipi_fmt
= msm_host
->format
;
763 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
767 dsi_write(msm_host
, REG_DSI_CTRL
, 0);
771 if (flags
& MIPI_DSI_MODE_VIDEO
) {
772 if (flags
& MIPI_DSI_MODE_VIDEO_HSE
)
773 data
|= DSI_VID_CFG0_PULSE_MODE_HSA_HE
;
774 if (flags
& MIPI_DSI_MODE_VIDEO_HFP
)
775 data
|= DSI_VID_CFG0_HFP_POWER_STOP
;
776 if (flags
& MIPI_DSI_MODE_VIDEO_HBP
)
777 data
|= DSI_VID_CFG0_HBP_POWER_STOP
;
778 if (flags
& MIPI_DSI_MODE_VIDEO_HSA
)
779 data
|= DSI_VID_CFG0_HSA_POWER_STOP
;
780 /* Always set low power stop mode for BLLP
781 * to let command engine send packets
783 data
|= DSI_VID_CFG0_EOF_BLLP_POWER_STOP
|
784 DSI_VID_CFG0_BLLP_POWER_STOP
;
785 data
|= DSI_VID_CFG0_TRAFFIC_MODE(dsi_get_traffic_mode(flags
));
786 data
|= DSI_VID_CFG0_DST_FORMAT(dsi_get_vid_fmt(mipi_fmt
));
787 data
|= DSI_VID_CFG0_VIRT_CHANNEL(msm_host
->channel
);
788 dsi_write(msm_host
, REG_DSI_VID_CFG0
, data
);
790 /* Do not swap RGB colors */
791 data
= DSI_VID_CFG1_RGB_SWAP(SWAP_RGB
);
792 dsi_write(msm_host
, REG_DSI_VID_CFG1
, 0);
794 /* Do not swap RGB colors */
795 data
= DSI_CMD_CFG0_RGB_SWAP(SWAP_RGB
);
796 data
|= DSI_CMD_CFG0_DST_FORMAT(dsi_get_cmd_fmt(mipi_fmt
));
797 dsi_write(msm_host
, REG_DSI_CMD_CFG0
, data
);
799 data
= DSI_CMD_CFG1_WR_MEM_START(MIPI_DCS_WRITE_MEMORY_START
) |
800 DSI_CMD_CFG1_WR_MEM_CONTINUE(
801 MIPI_DCS_WRITE_MEMORY_CONTINUE
);
802 /* Always insert DCS command */
803 data
|= DSI_CMD_CFG1_INSERT_DCS_COMMAND
;
804 dsi_write(msm_host
, REG_DSI_CMD_CFG1
, data
);
807 dsi_write(msm_host
, REG_DSI_CMD_DMA_CTRL
,
808 DSI_CMD_DMA_CTRL_FROM_FRAME_BUFFER
|
809 DSI_CMD_DMA_CTRL_LOW_POWER
);
812 /* Always assume dedicated TE pin */
813 data
|= DSI_TRIG_CTRL_TE
;
814 data
|= DSI_TRIG_CTRL_MDP_TRIGGER(TRIGGER_NONE
);
815 data
|= DSI_TRIG_CTRL_DMA_TRIGGER(TRIGGER_SW
);
816 data
|= DSI_TRIG_CTRL_STREAM(msm_host
->channel
);
817 if ((cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
) &&
818 (cfg_hnd
->minor
>= MSM_DSI_6G_VER_MINOR_V1_2
))
819 data
|= DSI_TRIG_CTRL_BLOCK_DMA_WITHIN_FRAME
;
820 dsi_write(msm_host
, REG_DSI_TRIG_CTRL
, data
);
822 data
= DSI_CLKOUT_TIMING_CTRL_T_CLK_POST(clk_post
) |
823 DSI_CLKOUT_TIMING_CTRL_T_CLK_PRE(clk_pre
);
824 dsi_write(msm_host
, REG_DSI_CLKOUT_TIMING_CTRL
, data
);
827 if (!(flags
& MIPI_DSI_MODE_EOT_PACKET
))
828 data
|= DSI_EOT_PACKET_CTRL_TX_EOT_APPEND
;
829 dsi_write(msm_host
, REG_DSI_EOT_PACKET_CTRL
, data
);
831 /* allow only ack-err-status to generate interrupt */
832 dsi_write(msm_host
, REG_DSI_ERR_INT_MASK0
, 0x13ff3fe0);
834 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_ERROR
, 1);
836 dsi_write(msm_host
, REG_DSI_CLK_CTRL
, DSI_CLK_CTRL_ENABLE_CLKS
);
838 data
= DSI_CTRL_CLK_EN
;
840 DBG("lane number=%d", msm_host
->lanes
);
841 data
|= ((DSI_CTRL_LANE0
<< msm_host
->lanes
) - DSI_CTRL_LANE0
);
843 dsi_write(msm_host
, REG_DSI_LANE_SWAP_CTRL
,
844 DSI_LANE_SWAP_CTRL_DLN_SWAP_SEL(msm_host
->dlane_swap
));
846 if (!(flags
& MIPI_DSI_CLOCK_NON_CONTINUOUS
))
847 dsi_write(msm_host
, REG_DSI_LANE_CTRL
,
848 DSI_LANE_CTRL_CLKLN_HS_FORCE_REQUEST
);
850 data
|= DSI_CTRL_ENABLE
;
852 dsi_write(msm_host
, REG_DSI_CTRL
, data
);
855 static void dsi_timing_setup(struct msm_dsi_host
*msm_host
)
857 struct drm_display_mode
*mode
= msm_host
->mode
;
858 u32 hs_start
= 0, vs_start
= 0; /* take sync start as 0 */
859 u32 h_total
= mode
->htotal
;
860 u32 v_total
= mode
->vtotal
;
861 u32 hs_end
= mode
->hsync_end
- mode
->hsync_start
;
862 u32 vs_end
= mode
->vsync_end
- mode
->vsync_start
;
863 u32 ha_start
= h_total
- mode
->hsync_start
;
864 u32 ha_end
= ha_start
+ mode
->hdisplay
;
865 u32 va_start
= v_total
- mode
->vsync_start
;
866 u32 va_end
= va_start
+ mode
->vdisplay
;
871 if (msm_host
->mode_flags
& MIPI_DSI_MODE_VIDEO
) {
872 dsi_write(msm_host
, REG_DSI_ACTIVE_H
,
873 DSI_ACTIVE_H_START(ha_start
) |
874 DSI_ACTIVE_H_END(ha_end
));
875 dsi_write(msm_host
, REG_DSI_ACTIVE_V
,
876 DSI_ACTIVE_V_START(va_start
) |
877 DSI_ACTIVE_V_END(va_end
));
878 dsi_write(msm_host
, REG_DSI_TOTAL
,
879 DSI_TOTAL_H_TOTAL(h_total
- 1) |
880 DSI_TOTAL_V_TOTAL(v_total
- 1));
882 dsi_write(msm_host
, REG_DSI_ACTIVE_HSYNC
,
883 DSI_ACTIVE_HSYNC_START(hs_start
) |
884 DSI_ACTIVE_HSYNC_END(hs_end
));
885 dsi_write(msm_host
, REG_DSI_ACTIVE_VSYNC_HPOS
, 0);
886 dsi_write(msm_host
, REG_DSI_ACTIVE_VSYNC_VPOS
,
887 DSI_ACTIVE_VSYNC_VPOS_START(vs_start
) |
888 DSI_ACTIVE_VSYNC_VPOS_END(vs_end
));
889 } else { /* command mode */
890 /* image data and 1 byte write_memory_start cmd */
891 wc
= mode
->hdisplay
* dsi_get_bpp(msm_host
->format
) / 8 + 1;
893 dsi_write(msm_host
, REG_DSI_CMD_MDP_STREAM_CTRL
,
894 DSI_CMD_MDP_STREAM_CTRL_WORD_COUNT(wc
) |
895 DSI_CMD_MDP_STREAM_CTRL_VIRTUAL_CHANNEL(
897 DSI_CMD_MDP_STREAM_CTRL_DATA_TYPE(
898 MIPI_DSI_DCS_LONG_WRITE
));
900 dsi_write(msm_host
, REG_DSI_CMD_MDP_STREAM_TOTAL
,
901 DSI_CMD_MDP_STREAM_TOTAL_H_TOTAL(mode
->hdisplay
) |
902 DSI_CMD_MDP_STREAM_TOTAL_V_TOTAL(mode
->vdisplay
));
906 static void dsi_sw_reset(struct msm_dsi_host
*msm_host
)
908 dsi_write(msm_host
, REG_DSI_CLK_CTRL
, DSI_CLK_CTRL_ENABLE_CLKS
);
909 wmb(); /* clocks need to be enabled before reset */
911 dsi_write(msm_host
, REG_DSI_RESET
, 1);
912 wmb(); /* make sure reset happen */
913 dsi_write(msm_host
, REG_DSI_RESET
, 0);
916 static void dsi_op_mode_config(struct msm_dsi_host
*msm_host
,
917 bool video_mode
, bool enable
)
921 dsi_ctrl
= dsi_read(msm_host
, REG_DSI_CTRL
);
924 dsi_ctrl
&= ~(DSI_CTRL_ENABLE
| DSI_CTRL_VID_MODE_EN
|
925 DSI_CTRL_CMD_MODE_EN
);
926 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_CMD_MDP_DONE
|
927 DSI_IRQ_MASK_VIDEO_DONE
, 0);
930 dsi_ctrl
|= DSI_CTRL_VID_MODE_EN
;
931 } else { /* command mode */
932 dsi_ctrl
|= DSI_CTRL_CMD_MODE_EN
;
933 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_CMD_MDP_DONE
, 1);
935 dsi_ctrl
|= DSI_CTRL_ENABLE
;
938 dsi_write(msm_host
, REG_DSI_CTRL
, dsi_ctrl
);
941 static void dsi_set_tx_power_mode(int mode
, struct msm_dsi_host
*msm_host
)
945 data
= dsi_read(msm_host
, REG_DSI_CMD_DMA_CTRL
);
948 data
&= ~DSI_CMD_DMA_CTRL_LOW_POWER
;
950 data
|= DSI_CMD_DMA_CTRL_LOW_POWER
;
952 dsi_write(msm_host
, REG_DSI_CMD_DMA_CTRL
, data
);
955 static void dsi_wait4video_done(struct msm_dsi_host
*msm_host
)
957 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_VIDEO_DONE
, 1);
959 reinit_completion(&msm_host
->video_comp
);
961 wait_for_completion_timeout(&msm_host
->video_comp
,
962 msecs_to_jiffies(70));
964 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_VIDEO_DONE
, 0);
967 static void dsi_wait4video_eng_busy(struct msm_dsi_host
*msm_host
)
969 if (!(msm_host
->mode_flags
& MIPI_DSI_MODE_VIDEO
))
972 if (msm_host
->power_on
) {
973 dsi_wait4video_done(msm_host
);
974 /* delay 4 ms to skip BLLP */
975 usleep_range(2000, 4000);
980 static int dsi_tx_buf_alloc(struct msm_dsi_host
*msm_host
, int size
)
982 struct drm_device
*dev
= msm_host
->dev
;
983 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
987 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
) {
988 mutex_lock(&dev
->struct_mutex
);
989 msm_host
->tx_gem_obj
= msm_gem_new(dev
, size
, MSM_BO_UNCACHED
);
990 if (IS_ERR(msm_host
->tx_gem_obj
)) {
991 ret
= PTR_ERR(msm_host
->tx_gem_obj
);
992 pr_err("%s: failed to allocate gem, %d\n",
994 msm_host
->tx_gem_obj
= NULL
;
995 mutex_unlock(&dev
->struct_mutex
);
999 ret
= msm_gem_get_iova_locked(msm_host
->tx_gem_obj
, 0, &iova
);
1000 mutex_unlock(&dev
->struct_mutex
);
1002 pr_err("%s: failed to get iova, %d\n", __func__
, ret
);
1007 pr_err("%s: buf NOT 8 bytes aligned\n", __func__
);
1011 msm_host
->tx_size
= msm_host
->tx_gem_obj
->size
;
1013 msm_host
->tx_buf
= dma_alloc_coherent(dev
->dev
, size
,
1014 &msm_host
->tx_buf_paddr
, GFP_KERNEL
);
1015 if (!msm_host
->tx_buf
) {
1017 pr_err("%s: failed to allocate tx buf, %d\n",
1022 msm_host
->tx_size
= size
;
1028 static void dsi_tx_buf_free(struct msm_dsi_host
*msm_host
)
1030 struct drm_device
*dev
= msm_host
->dev
;
1032 if (msm_host
->tx_gem_obj
) {
1033 msm_gem_put_iova(msm_host
->tx_gem_obj
, 0);
1034 mutex_lock(&dev
->struct_mutex
);
1035 msm_gem_free_object(msm_host
->tx_gem_obj
);
1036 msm_host
->tx_gem_obj
= NULL
;
1037 mutex_unlock(&dev
->struct_mutex
);
1040 if (msm_host
->tx_buf
)
1041 dma_free_coherent(dev
->dev
, msm_host
->tx_size
, msm_host
->tx_buf
,
1042 msm_host
->tx_buf_paddr
);
1046 * prepare cmd buffer to be txed
1048 static int dsi_cmd_dma_add(struct msm_dsi_host
*msm_host
,
1049 const struct mipi_dsi_msg
*msg
)
1051 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
1052 struct mipi_dsi_packet packet
;
1057 ret
= mipi_dsi_create_packet(&packet
, msg
);
1059 pr_err("%s: create packet failed, %d\n", __func__
, ret
);
1062 len
= (packet
.size
+ 3) & (~0x3);
1064 if (len
> msm_host
->tx_size
) {
1065 pr_err("%s: packet size is too big\n", __func__
);
1069 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
) {
1070 data
= msm_gem_get_vaddr(msm_host
->tx_gem_obj
);
1072 ret
= PTR_ERR(data
);
1073 pr_err("%s: get vaddr failed, %d\n", __func__
, ret
);
1077 data
= msm_host
->tx_buf
;
1080 /* MSM specific command format in memory */
1081 data
[0] = packet
.header
[1];
1082 data
[1] = packet
.header
[2];
1083 data
[2] = packet
.header
[0];
1084 data
[3] = BIT(7); /* Last packet */
1085 if (mipi_dsi_packet_format_is_long(msg
->type
))
1087 if (msg
->rx_buf
&& msg
->rx_len
)
1091 if (packet
.payload
&& packet
.payload_length
)
1092 memcpy(data
+ 4, packet
.payload
, packet
.payload_length
);
1094 /* Append 0xff to the end */
1095 if (packet
.size
< len
)
1096 memset(data
+ packet
.size
, 0xff, len
- packet
.size
);
1098 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
)
1099 msm_gem_put_vaddr(msm_host
->tx_gem_obj
);
1105 * dsi_short_read1_resp: 1 parameter
1107 static int dsi_short_read1_resp(u8
*buf
, const struct mipi_dsi_msg
*msg
)
1109 u8
*data
= msg
->rx_buf
;
1110 if (data
&& (msg
->rx_len
>= 1)) {
1111 *data
= buf
[1]; /* strip out dcs type */
1114 pr_err("%s: read data does not match with rx_buf len %zu\n",
1115 __func__
, msg
->rx_len
);
1121 * dsi_short_read2_resp: 2 parameter
1123 static int dsi_short_read2_resp(u8
*buf
, const struct mipi_dsi_msg
*msg
)
1125 u8
*data
= msg
->rx_buf
;
1126 if (data
&& (msg
->rx_len
>= 2)) {
1127 data
[0] = buf
[1]; /* strip out dcs type */
1131 pr_err("%s: read data does not match with rx_buf len %zu\n",
1132 __func__
, msg
->rx_len
);
1137 static int dsi_long_read_resp(u8
*buf
, const struct mipi_dsi_msg
*msg
)
1139 /* strip out 4 byte dcs header */
1140 if (msg
->rx_buf
&& msg
->rx_len
)
1141 memcpy(msg
->rx_buf
, buf
+ 4, msg
->rx_len
);
1146 static int dsi_cmd_dma_tx(struct msm_dsi_host
*msm_host
, int len
)
1148 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
1153 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
) {
1154 ret
= msm_gem_get_iova(msm_host
->tx_gem_obj
, 0, &dma_base
);
1156 pr_err("%s: failed to get iova: %d\n", __func__
, ret
);
1160 dma_base
= msm_host
->tx_buf_paddr
;
1163 reinit_completion(&msm_host
->dma_comp
);
1165 dsi_wait4video_eng_busy(msm_host
);
1167 triggered
= msm_dsi_manager_cmd_xfer_trigger(
1168 msm_host
->id
, dma_base
, len
);
1170 ret
= wait_for_completion_timeout(&msm_host
->dma_comp
,
1171 msecs_to_jiffies(200));
1183 static int dsi_cmd_dma_rx(struct msm_dsi_host
*msm_host
,
1184 u8
*buf
, int rx_byte
, int pkt_size
)
1186 u32
*lp
, *temp
, data
;
1190 int repeated_bytes
= 0;
1191 int buf_offset
= buf
- msm_host
->rx_buf
;
1195 cnt
= (rx_byte
+ 3) >> 2;
1197 cnt
= 4; /* 4 x 32 bits registers only */
1202 read_cnt
= pkt_size
+ 6;
1205 * In case of multiple reads from the panel, after the first read, there
1206 * is possibility that there are some bytes in the payload repeating in
1207 * the RDBK_DATA registers. Since we read all the parameters from the
1208 * panel right from the first byte for every pass. We need to skip the
1209 * repeating bytes and then append the new parameters to the rx buffer.
1211 if (read_cnt
> 16) {
1213 /* Any data more than 16 bytes will be shifted out.
1214 * The temp read buffer should already contain these bytes.
1215 * The remaining bytes in read buffer are the repeated bytes.
1217 bytes_shifted
= read_cnt
- 16;
1218 repeated_bytes
= buf_offset
- bytes_shifted
;
1221 for (i
= cnt
- 1; i
>= 0; i
--) {
1222 data
= dsi_read(msm_host
, REG_DSI_RDBK_DATA(i
));
1223 *temp
++ = ntohl(data
); /* to host byte order */
1224 DBG("data = 0x%x and ntohl(data) = 0x%x", data
, ntohl(data
));
1227 for (i
= repeated_bytes
; i
< 16; i
++)
1233 static int dsi_cmds2buf_tx(struct msm_dsi_host
*msm_host
,
1234 const struct mipi_dsi_msg
*msg
)
1237 int bllp_len
= msm_host
->mode
->hdisplay
*
1238 dsi_get_bpp(msm_host
->format
) / 8;
1240 len
= dsi_cmd_dma_add(msm_host
, msg
);
1242 pr_err("%s: failed to add cmd type = 0x%x\n",
1243 __func__
, msg
->type
);
1247 /* for video mode, do not send cmds more than
1248 * one pixel line, since it only transmit it
1251 /* TODO: if the command is sent in LP mode, the bit rate is only
1252 * half of esc clk rate. In this case, if the video is already
1253 * actively streaming, we need to check more carefully if the
1254 * command can be fit into one BLLP.
1256 if ((msm_host
->mode_flags
& MIPI_DSI_MODE_VIDEO
) && (len
> bllp_len
)) {
1257 pr_err("%s: cmd cannot fit into BLLP period, len=%d\n",
1262 ret
= dsi_cmd_dma_tx(msm_host
, len
);
1264 pr_err("%s: cmd dma tx failed, type=0x%x, data0=0x%x, len=%d\n",
1265 __func__
, msg
->type
, (*(u8
*)(msg
->tx_buf
)), len
);
1272 static void dsi_sw_reset_restore(struct msm_dsi_host
*msm_host
)
1276 data0
= dsi_read(msm_host
, REG_DSI_CTRL
);
1278 data1
&= ~DSI_CTRL_ENABLE
;
1279 dsi_write(msm_host
, REG_DSI_CTRL
, data1
);
1281 * dsi controller need to be disabled before
1286 dsi_write(msm_host
, REG_DSI_CLK_CTRL
, DSI_CLK_CTRL_ENABLE_CLKS
);
1287 wmb(); /* make sure clocks enabled */
1289 /* dsi controller can only be reset while clocks are running */
1290 dsi_write(msm_host
, REG_DSI_RESET
, 1);
1291 wmb(); /* make sure reset happen */
1292 dsi_write(msm_host
, REG_DSI_RESET
, 0);
1293 wmb(); /* controller out of reset */
1294 dsi_write(msm_host
, REG_DSI_CTRL
, data0
);
1295 wmb(); /* make sure dsi controller enabled again */
1298 static void dsi_hpd_worker(struct work_struct
*work
)
1300 struct msm_dsi_host
*msm_host
=
1301 container_of(work
, struct msm_dsi_host
, hpd_work
);
1303 drm_helper_hpd_irq_event(msm_host
->dev
);
1306 static void dsi_err_worker(struct work_struct
*work
)
1308 struct msm_dsi_host
*msm_host
=
1309 container_of(work
, struct msm_dsi_host
, err_work
);
1310 u32 status
= msm_host
->err_work_state
;
1312 pr_err_ratelimited("%s: status=%x\n", __func__
, status
);
1313 if (status
& DSI_ERR_STATE_MDP_FIFO_UNDERFLOW
)
1314 dsi_sw_reset_restore(msm_host
);
1316 /* It is safe to clear here because error irq is disabled. */
1317 msm_host
->err_work_state
= 0;
1319 /* enable dsi error interrupt */
1320 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_ERROR
, 1);
1323 static void dsi_ack_err_status(struct msm_dsi_host
*msm_host
)
1327 status
= dsi_read(msm_host
, REG_DSI_ACK_ERR_STATUS
);
1330 dsi_write(msm_host
, REG_DSI_ACK_ERR_STATUS
, status
);
1331 /* Writing of an extra 0 needed to clear error bits */
1332 dsi_write(msm_host
, REG_DSI_ACK_ERR_STATUS
, 0);
1333 msm_host
->err_work_state
|= DSI_ERR_STATE_ACK
;
1337 static void dsi_timeout_status(struct msm_dsi_host
*msm_host
)
1341 status
= dsi_read(msm_host
, REG_DSI_TIMEOUT_STATUS
);
1344 dsi_write(msm_host
, REG_DSI_TIMEOUT_STATUS
, status
);
1345 msm_host
->err_work_state
|= DSI_ERR_STATE_TIMEOUT
;
1349 static void dsi_dln0_phy_err(struct msm_dsi_host
*msm_host
)
1353 status
= dsi_read(msm_host
, REG_DSI_DLN0_PHY_ERR
);
1355 if (status
& (DSI_DLN0_PHY_ERR_DLN0_ERR_ESC
|
1356 DSI_DLN0_PHY_ERR_DLN0_ERR_SYNC_ESC
|
1357 DSI_DLN0_PHY_ERR_DLN0_ERR_CONTROL
|
1358 DSI_DLN0_PHY_ERR_DLN0_ERR_CONTENTION_LP0
|
1359 DSI_DLN0_PHY_ERR_DLN0_ERR_CONTENTION_LP1
)) {
1360 dsi_write(msm_host
, REG_DSI_DLN0_PHY_ERR
, status
);
1361 msm_host
->err_work_state
|= DSI_ERR_STATE_DLN0_PHY
;
1365 static void dsi_fifo_status(struct msm_dsi_host
*msm_host
)
1369 status
= dsi_read(msm_host
, REG_DSI_FIFO_STATUS
);
1371 /* fifo underflow, overflow */
1373 dsi_write(msm_host
, REG_DSI_FIFO_STATUS
, status
);
1374 msm_host
->err_work_state
|= DSI_ERR_STATE_FIFO
;
1375 if (status
& DSI_FIFO_STATUS_CMD_MDP_FIFO_UNDERFLOW
)
1376 msm_host
->err_work_state
|=
1377 DSI_ERR_STATE_MDP_FIFO_UNDERFLOW
;
1381 static void dsi_status(struct msm_dsi_host
*msm_host
)
1385 status
= dsi_read(msm_host
, REG_DSI_STATUS0
);
1387 if (status
& DSI_STATUS0_INTERLEAVE_OP_CONTENTION
) {
1388 dsi_write(msm_host
, REG_DSI_STATUS0
, status
);
1389 msm_host
->err_work_state
|=
1390 DSI_ERR_STATE_INTERLEAVE_OP_CONTENTION
;
1394 static void dsi_clk_status(struct msm_dsi_host
*msm_host
)
1398 status
= dsi_read(msm_host
, REG_DSI_CLK_STATUS
);
1400 if (status
& DSI_CLK_STATUS_PLL_UNLOCKED
) {
1401 dsi_write(msm_host
, REG_DSI_CLK_STATUS
, status
);
1402 msm_host
->err_work_state
|= DSI_ERR_STATE_PLL_UNLOCKED
;
1406 static void dsi_error(struct msm_dsi_host
*msm_host
)
1408 /* disable dsi error interrupt */
1409 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_ERROR
, 0);
1411 dsi_clk_status(msm_host
);
1412 dsi_fifo_status(msm_host
);
1413 dsi_ack_err_status(msm_host
);
1414 dsi_timeout_status(msm_host
);
1415 dsi_status(msm_host
);
1416 dsi_dln0_phy_err(msm_host
);
1418 queue_work(msm_host
->workqueue
, &msm_host
->err_work
);
1421 static irqreturn_t
dsi_host_irq(int irq
, void *ptr
)
1423 struct msm_dsi_host
*msm_host
= ptr
;
1425 unsigned long flags
;
1427 if (!msm_host
->ctrl_base
)
1430 spin_lock_irqsave(&msm_host
->intr_lock
, flags
);
1431 isr
= dsi_read(msm_host
, REG_DSI_INTR_CTRL
);
1432 dsi_write(msm_host
, REG_DSI_INTR_CTRL
, isr
);
1433 spin_unlock_irqrestore(&msm_host
->intr_lock
, flags
);
1435 DBG("isr=0x%x, id=%d", isr
, msm_host
->id
);
1437 if (isr
& DSI_IRQ_ERROR
)
1438 dsi_error(msm_host
);
1440 if (isr
& DSI_IRQ_VIDEO_DONE
)
1441 complete(&msm_host
->video_comp
);
1443 if (isr
& DSI_IRQ_CMD_DMA_DONE
)
1444 complete(&msm_host
->dma_comp
);
1449 static int dsi_host_init_panel_gpios(struct msm_dsi_host
*msm_host
,
1450 struct device
*panel_device
)
1452 msm_host
->disp_en_gpio
= devm_gpiod_get_optional(panel_device
,
1455 if (IS_ERR(msm_host
->disp_en_gpio
)) {
1456 DBG("cannot get disp-enable-gpios %ld",
1457 PTR_ERR(msm_host
->disp_en_gpio
));
1458 return PTR_ERR(msm_host
->disp_en_gpio
);
1461 msm_host
->te_gpio
= devm_gpiod_get_optional(panel_device
, "disp-te",
1463 if (IS_ERR(msm_host
->te_gpio
)) {
1464 DBG("cannot get disp-te-gpios %ld", PTR_ERR(msm_host
->te_gpio
));
1465 return PTR_ERR(msm_host
->te_gpio
);
1471 static int dsi_host_attach(struct mipi_dsi_host
*host
,
1472 struct mipi_dsi_device
*dsi
)
1474 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1477 if (dsi
->lanes
> msm_host
->num_data_lanes
)
1480 msm_host
->channel
= dsi
->channel
;
1481 msm_host
->lanes
= dsi
->lanes
;
1482 msm_host
->format
= dsi
->format
;
1483 msm_host
->mode_flags
= dsi
->mode_flags
;
1485 /* Some gpios defined in panel DT need to be controlled by host */
1486 ret
= dsi_host_init_panel_gpios(msm_host
, &dsi
->dev
);
1490 DBG("id=%d", msm_host
->id
);
1492 queue_work(msm_host
->workqueue
, &msm_host
->hpd_work
);
1497 static int dsi_host_detach(struct mipi_dsi_host
*host
,
1498 struct mipi_dsi_device
*dsi
)
1500 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1502 msm_host
->device_node
= NULL
;
1504 DBG("id=%d", msm_host
->id
);
1506 queue_work(msm_host
->workqueue
, &msm_host
->hpd_work
);
1511 static ssize_t
dsi_host_transfer(struct mipi_dsi_host
*host
,
1512 const struct mipi_dsi_msg
*msg
)
1514 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1517 if (!msg
|| !msm_host
->power_on
)
1520 mutex_lock(&msm_host
->cmd_mutex
);
1521 ret
= msm_dsi_manager_cmd_xfer(msm_host
->id
, msg
);
1522 mutex_unlock(&msm_host
->cmd_mutex
);
1527 static struct mipi_dsi_host_ops dsi_host_ops
= {
1528 .attach
= dsi_host_attach
,
1529 .detach
= dsi_host_detach
,
1530 .transfer
= dsi_host_transfer
,
1534 * List of supported physical to logical lane mappings.
1535 * For example, the 2nd entry represents the following mapping:
1537 * "3012": Logic 3->Phys 0; Logic 0->Phys 1; Logic 1->Phys 2; Logic 2->Phys 3;
1539 static const int supported_data_lane_swaps
[][4] = {
1550 static int dsi_host_parse_lane_data(struct msm_dsi_host
*msm_host
,
1551 struct device_node
*ep
)
1553 struct device
*dev
= &msm_host
->pdev
->dev
;
1554 struct property
*prop
;
1556 int ret
, i
, len
, num_lanes
;
1558 prop
= of_find_property(ep
, "data-lanes", &len
);
1560 dev_dbg(dev
, "failed to find data lane mapping\n");
1564 num_lanes
= len
/ sizeof(u32
);
1566 if (num_lanes
< 1 || num_lanes
> 4) {
1567 dev_err(dev
, "bad number of data lanes\n");
1571 msm_host
->num_data_lanes
= num_lanes
;
1573 ret
= of_property_read_u32_array(ep
, "data-lanes", lane_map
,
1576 dev_err(dev
, "failed to read lane data\n");
1581 * compare DT specified physical-logical lane mappings with the ones
1582 * supported by hardware
1584 for (i
= 0; i
< ARRAY_SIZE(supported_data_lane_swaps
); i
++) {
1585 const int *swap
= supported_data_lane_swaps
[i
];
1589 * the data-lanes array we get from DT has a logical->physical
1590 * mapping. The "data lane swap" register field represents
1591 * supported configurations in a physical->logical mapping.
1592 * Translate the DT mapping to what we understand and find a
1593 * configuration that works.
1595 for (j
= 0; j
< num_lanes
; j
++) {
1596 if (lane_map
[j
] < 0 || lane_map
[j
] > 3)
1597 dev_err(dev
, "bad physical lane entry %u\n",
1600 if (swap
[lane_map
[j
]] != j
)
1604 if (j
== num_lanes
) {
1605 msm_host
->dlane_swap
= i
;
1613 static int dsi_host_parse_dt(struct msm_dsi_host
*msm_host
)
1615 struct device
*dev
= &msm_host
->pdev
->dev
;
1616 struct device_node
*np
= dev
->of_node
;
1617 struct device_node
*endpoint
, *device_node
;
1621 * Get the endpoint of the output port of the DSI host. In our case,
1622 * this is mapped to port number with reg = 1. Don't return an error if
1623 * the remote endpoint isn't defined. It's possible that there is
1624 * nothing connected to the dsi output.
1626 endpoint
= of_graph_get_endpoint_by_regs(np
, 1, -1);
1628 dev_dbg(dev
, "%s: no endpoint\n", __func__
);
1632 ret
= dsi_host_parse_lane_data(msm_host
, endpoint
);
1634 dev_err(dev
, "%s: invalid lane configuration %d\n",
1639 /* Get panel node from the output port's endpoint data */
1640 device_node
= of_graph_get_remote_port_parent(endpoint
);
1642 dev_err(dev
, "%s: no valid device\n", __func__
);
1647 msm_host
->device_node
= device_node
;
1649 if (of_property_read_bool(np
, "syscon-sfpb")) {
1650 msm_host
->sfpb
= syscon_regmap_lookup_by_phandle(np
,
1652 if (IS_ERR(msm_host
->sfpb
)) {
1653 dev_err(dev
, "%s: failed to get sfpb regmap\n",
1655 ret
= PTR_ERR(msm_host
->sfpb
);
1659 of_node_put(device_node
);
1662 of_node_put(endpoint
);
1667 static int dsi_host_get_id(struct msm_dsi_host
*msm_host
)
1669 struct platform_device
*pdev
= msm_host
->pdev
;
1670 const struct msm_dsi_config
*cfg
= msm_host
->cfg_hnd
->cfg
;
1671 struct resource
*res
;
1674 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "dsi_ctrl");
1678 for (i
= 0; i
< cfg
->num_dsi
; i
++) {
1679 if (cfg
->io_start
[i
] == res
->start
)
1686 int msm_dsi_host_init(struct msm_dsi
*msm_dsi
)
1688 struct msm_dsi_host
*msm_host
= NULL
;
1689 struct platform_device
*pdev
= msm_dsi
->pdev
;
1692 msm_host
= devm_kzalloc(&pdev
->dev
, sizeof(*msm_host
), GFP_KERNEL
);
1694 pr_err("%s: FAILED: cannot alloc dsi host\n",
1700 msm_host
->pdev
= pdev
;
1702 ret
= dsi_host_parse_dt(msm_host
);
1704 pr_err("%s: failed to parse dt\n", __func__
);
1708 msm_host
->ctrl_base
= msm_ioremap(pdev
, "dsi_ctrl", "DSI CTRL");
1709 if (IS_ERR(msm_host
->ctrl_base
)) {
1710 pr_err("%s: unable to map Dsi ctrl base\n", __func__
);
1711 ret
= PTR_ERR(msm_host
->ctrl_base
);
1715 msm_host
->cfg_hnd
= dsi_get_config(msm_host
);
1716 if (!msm_host
->cfg_hnd
) {
1718 pr_err("%s: get config failed\n", __func__
);
1722 msm_host
->id
= dsi_host_get_id(msm_host
);
1723 if (msm_host
->id
< 0) {
1725 pr_err("%s: unable to identify DSI host index\n", __func__
);
1729 /* fixup base address by io offset */
1730 msm_host
->ctrl_base
+= msm_host
->cfg_hnd
->cfg
->io_offset
;
1732 ret
= dsi_regulator_init(msm_host
);
1734 pr_err("%s: regulator init failed\n", __func__
);
1738 ret
= dsi_clk_init(msm_host
);
1740 pr_err("%s: unable to initialize dsi clks\n", __func__
);
1744 msm_host
->rx_buf
= devm_kzalloc(&pdev
->dev
, SZ_4K
, GFP_KERNEL
);
1745 if (!msm_host
->rx_buf
) {
1746 pr_err("%s: alloc rx temp buf failed\n", __func__
);
1750 init_completion(&msm_host
->dma_comp
);
1751 init_completion(&msm_host
->video_comp
);
1752 mutex_init(&msm_host
->dev_mutex
);
1753 mutex_init(&msm_host
->cmd_mutex
);
1754 mutex_init(&msm_host
->clk_mutex
);
1755 spin_lock_init(&msm_host
->intr_lock
);
1757 /* setup workqueue */
1758 msm_host
->workqueue
= alloc_ordered_workqueue("dsi_drm_work", 0);
1759 INIT_WORK(&msm_host
->err_work
, dsi_err_worker
);
1760 INIT_WORK(&msm_host
->hpd_work
, dsi_hpd_worker
);
1762 msm_dsi
->host
= &msm_host
->base
;
1763 msm_dsi
->id
= msm_host
->id
;
1765 DBG("Dsi Host %d initialized", msm_host
->id
);
1772 void msm_dsi_host_destroy(struct mipi_dsi_host
*host
)
1774 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1777 dsi_tx_buf_free(msm_host
);
1778 if (msm_host
->workqueue
) {
1779 flush_workqueue(msm_host
->workqueue
);
1780 destroy_workqueue(msm_host
->workqueue
);
1781 msm_host
->workqueue
= NULL
;
1784 mutex_destroy(&msm_host
->clk_mutex
);
1785 mutex_destroy(&msm_host
->cmd_mutex
);
1786 mutex_destroy(&msm_host
->dev_mutex
);
1789 int msm_dsi_host_modeset_init(struct mipi_dsi_host
*host
,
1790 struct drm_device
*dev
)
1792 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1793 struct platform_device
*pdev
= msm_host
->pdev
;
1796 msm_host
->irq
= irq_of_parse_and_map(pdev
->dev
.of_node
, 0);
1797 if (msm_host
->irq
< 0) {
1798 ret
= msm_host
->irq
;
1799 dev_err(dev
->dev
, "failed to get irq: %d\n", ret
);
1803 ret
= devm_request_irq(&pdev
->dev
, msm_host
->irq
,
1804 dsi_host_irq
, IRQF_TRIGGER_HIGH
| IRQF_ONESHOT
,
1805 "dsi_isr", msm_host
);
1807 dev_err(&pdev
->dev
, "failed to request IRQ%u: %d\n",
1808 msm_host
->irq
, ret
);
1812 msm_host
->dev
= dev
;
1813 ret
= dsi_tx_buf_alloc(msm_host
, SZ_4K
);
1815 pr_err("%s: alloc tx gem obj failed, %d\n", __func__
, ret
);
1822 int msm_dsi_host_register(struct mipi_dsi_host
*host
, bool check_defer
)
1824 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1827 /* Register mipi dsi host */
1828 if (!msm_host
->registered
) {
1829 host
->dev
= &msm_host
->pdev
->dev
;
1830 host
->ops
= &dsi_host_ops
;
1831 ret
= mipi_dsi_host_register(host
);
1835 msm_host
->registered
= true;
1837 /* If the panel driver has not been probed after host register,
1838 * we should defer the host's probe.
1839 * It makes sure panel is connected when fbcon detects
1840 * connector status and gets the proper display mode to
1841 * create framebuffer.
1842 * Don't try to defer if there is nothing connected to the dsi
1845 if (check_defer
&& msm_host
->device_node
) {
1846 if (!of_drm_find_panel(msm_host
->device_node
))
1847 if (!of_drm_find_bridge(msm_host
->device_node
))
1848 return -EPROBE_DEFER
;
1855 void msm_dsi_host_unregister(struct mipi_dsi_host
*host
)
1857 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1859 if (msm_host
->registered
) {
1860 mipi_dsi_host_unregister(host
);
1863 msm_host
->registered
= false;
1867 int msm_dsi_host_xfer_prepare(struct mipi_dsi_host
*host
,
1868 const struct mipi_dsi_msg
*msg
)
1870 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1872 /* TODO: make sure dsi_cmd_mdp is idle.
1873 * Since DSI6G v1.2.0, we can set DSI_TRIG_CTRL.BLOCK_DMA_WITHIN_FRAME
1874 * to ask H/W to wait until cmd mdp is idle. S/W wait is not needed.
1875 * How to handle the old versions? Wait for mdp cmd done?
1879 * mdss interrupt is generated in mdp core clock domain
1880 * mdp clock need to be enabled to receive dsi interrupt
1882 dsi_clk_ctrl(msm_host
, 1);
1884 /* TODO: vote for bus bandwidth */
1886 if (!(msg
->flags
& MIPI_DSI_MSG_USE_LPM
))
1887 dsi_set_tx_power_mode(0, msm_host
);
1889 msm_host
->dma_cmd_ctrl_restore
= dsi_read(msm_host
, REG_DSI_CTRL
);
1890 dsi_write(msm_host
, REG_DSI_CTRL
,
1891 msm_host
->dma_cmd_ctrl_restore
|
1892 DSI_CTRL_CMD_MODE_EN
|
1894 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_CMD_DMA_DONE
, 1);
1899 void msm_dsi_host_xfer_restore(struct mipi_dsi_host
*host
,
1900 const struct mipi_dsi_msg
*msg
)
1902 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1904 dsi_intr_ctrl(msm_host
, DSI_IRQ_MASK_CMD_DMA_DONE
, 0);
1905 dsi_write(msm_host
, REG_DSI_CTRL
, msm_host
->dma_cmd_ctrl_restore
);
1907 if (!(msg
->flags
& MIPI_DSI_MSG_USE_LPM
))
1908 dsi_set_tx_power_mode(1, msm_host
);
1910 /* TODO: unvote for bus bandwidth */
1912 dsi_clk_ctrl(msm_host
, 0);
1915 int msm_dsi_host_cmd_tx(struct mipi_dsi_host
*host
,
1916 const struct mipi_dsi_msg
*msg
)
1918 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1920 return dsi_cmds2buf_tx(msm_host
, msg
);
1923 int msm_dsi_host_cmd_rx(struct mipi_dsi_host
*host
,
1924 const struct mipi_dsi_msg
*msg
)
1926 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
1927 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
1928 int data_byte
, rx_byte
, dlen
, end
;
1929 int short_response
, diff
, pkt_size
, ret
= 0;
1931 int rlen
= msg
->rx_len
;
1940 data_byte
= 10; /* first read */
1941 if (rlen
< data_byte
)
1944 pkt_size
= data_byte
;
1945 rx_byte
= data_byte
+ 6; /* 4 header + 2 crc */
1948 buf
= msm_host
->rx_buf
;
1951 u8 tx
[2] = {pkt_size
& 0xff, pkt_size
>> 8};
1952 struct mipi_dsi_msg max_pkt_size_msg
= {
1953 .channel
= msg
->channel
,
1954 .type
= MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE
,
1959 DBG("rlen=%d pkt_size=%d rx_byte=%d",
1960 rlen
, pkt_size
, rx_byte
);
1962 ret
= dsi_cmds2buf_tx(msm_host
, &max_pkt_size_msg
);
1964 pr_err("%s: Set max pkt size failed, %d\n",
1969 if ((cfg_hnd
->major
== MSM_DSI_VER_MAJOR_6G
) &&
1970 (cfg_hnd
->minor
>= MSM_DSI_6G_VER_MINOR_V1_1
)) {
1971 /* Clear the RDBK_DATA registers */
1972 dsi_write(msm_host
, REG_DSI_RDBK_DATA_CTRL
,
1973 DSI_RDBK_DATA_CTRL_CLR
);
1974 wmb(); /* make sure the RDBK registers are cleared */
1975 dsi_write(msm_host
, REG_DSI_RDBK_DATA_CTRL
, 0);
1976 wmb(); /* release cleared status before transfer */
1979 ret
= dsi_cmds2buf_tx(msm_host
, msg
);
1980 if (ret
< msg
->tx_len
) {
1981 pr_err("%s: Read cmd Tx failed, %d\n", __func__
, ret
);
1986 * once cmd_dma_done interrupt received,
1987 * return data from client is ready and stored
1988 * at RDBK_DATA register already
1989 * since rx fifo is 16 bytes, dcs header is kept at first loop,
1990 * after that dcs header lost during shift into registers
1992 dlen
= dsi_cmd_dma_rx(msm_host
, buf
, rx_byte
, pkt_size
);
2000 if (rlen
<= data_byte
) {
2001 diff
= data_byte
- rlen
;
2009 dlen
-= 2; /* 2 crc */
2011 buf
+= dlen
; /* next start position */
2012 data_byte
= 14; /* NOT first read */
2013 if (rlen
< data_byte
)
2016 pkt_size
+= data_byte
;
2017 DBG("buf=%p dlen=%d diff=%d", buf
, dlen
, diff
);
2022 * For single Long read, if the requested rlen < 10,
2023 * we need to shift the start position of rx
2024 * data buffer to skip the bytes which are not
2027 if (pkt_size
< 10 && !short_response
)
2028 buf
= msm_host
->rx_buf
+ (10 - rlen
);
2030 buf
= msm_host
->rx_buf
;
2034 case MIPI_DSI_RX_ACKNOWLEDGE_AND_ERROR_REPORT
:
2035 pr_err("%s: rx ACK_ERR_PACLAGE\n", __func__
);
2038 case MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_1BYTE
:
2039 case MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_1BYTE
:
2040 ret
= dsi_short_read1_resp(buf
, msg
);
2042 case MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_2BYTE
:
2043 case MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_2BYTE
:
2044 ret
= dsi_short_read2_resp(buf
, msg
);
2046 case MIPI_DSI_RX_GENERIC_LONG_READ_RESPONSE
:
2047 case MIPI_DSI_RX_DCS_LONG_READ_RESPONSE
:
2048 ret
= dsi_long_read_resp(buf
, msg
);
2051 pr_warn("%s:Invalid response cmd\n", __func__
);
2058 void msm_dsi_host_cmd_xfer_commit(struct mipi_dsi_host
*host
, u32 dma_base
,
2061 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2063 dsi_write(msm_host
, REG_DSI_DMA_BASE
, dma_base
);
2064 dsi_write(msm_host
, REG_DSI_DMA_LEN
, len
);
2065 dsi_write(msm_host
, REG_DSI_TRIG_DMA
, 1);
2067 /* Make sure trigger happens */
2071 int msm_dsi_host_set_src_pll(struct mipi_dsi_host
*host
,
2072 struct msm_dsi_pll
*src_pll
)
2074 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2075 const struct msm_dsi_cfg_handler
*cfg_hnd
= msm_host
->cfg_hnd
;
2076 struct clk
*byte_clk_provider
, *pixel_clk_provider
;
2079 ret
= msm_dsi_pll_get_clk_provider(src_pll
,
2080 &byte_clk_provider
, &pixel_clk_provider
);
2082 pr_info("%s: can't get provider from pll, don't set parent\n",
2087 ret
= clk_set_parent(msm_host
->byte_clk_src
, byte_clk_provider
);
2089 pr_err("%s: can't set parent to byte_clk_src. ret=%d\n",
2094 ret
= clk_set_parent(msm_host
->pixel_clk_src
, pixel_clk_provider
);
2096 pr_err("%s: can't set parent to pixel_clk_src. ret=%d\n",
2101 if (cfg_hnd
->major
== MSM_DSI_VER_MAJOR_V2
) {
2102 ret
= clk_set_parent(msm_host
->dsi_clk_src
, pixel_clk_provider
);
2104 pr_err("%s: can't set parent to dsi_clk_src. ret=%d\n",
2109 ret
= clk_set_parent(msm_host
->esc_clk_src
, byte_clk_provider
);
2111 pr_err("%s: can't set parent to esc_clk_src. ret=%d\n",
2121 int msm_dsi_host_enable(struct mipi_dsi_host
*host
)
2123 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2125 dsi_op_mode_config(msm_host
,
2126 !!(msm_host
->mode_flags
& MIPI_DSI_MODE_VIDEO
), true);
2128 /* TODO: clock should be turned off for command mode,
2129 * and only turned on before MDP START.
2130 * This part of code should be enabled once mdp driver support it.
2132 /* if (msm_panel->mode == MSM_DSI_CMD_MODE)
2133 dsi_clk_ctrl(msm_host, 0); */
2138 int msm_dsi_host_disable(struct mipi_dsi_host
*host
)
2140 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2142 dsi_op_mode_config(msm_host
,
2143 !!(msm_host
->mode_flags
& MIPI_DSI_MODE_VIDEO
), false);
2145 /* Since we have disabled INTF, the video engine won't stop so that
2146 * the cmd engine will be blocked.
2147 * Reset to disable video engine so that we can send off cmd.
2149 dsi_sw_reset(msm_host
);
2154 static void msm_dsi_sfpb_config(struct msm_dsi_host
*msm_host
, bool enable
)
2156 enum sfpb_ahb_arb_master_port_en en
;
2158 if (!msm_host
->sfpb
)
2161 en
= enable
? SFPB_MASTER_PORT_ENABLE
: SFPB_MASTER_PORT_DISABLE
;
2163 regmap_update_bits(msm_host
->sfpb
, REG_SFPB_GPREG
,
2164 SFPB_GPREG_MASTER_PORT_EN__MASK
,
2165 SFPB_GPREG_MASTER_PORT_EN(en
));
2168 int msm_dsi_host_power_on(struct mipi_dsi_host
*host
)
2170 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2171 u32 clk_pre
= 0, clk_post
= 0;
2174 mutex_lock(&msm_host
->dev_mutex
);
2175 if (msm_host
->power_on
) {
2176 DBG("dsi host already on");
2180 msm_dsi_sfpb_config(msm_host
, true);
2182 ret
= dsi_calc_clk_rate(msm_host
);
2184 pr_err("%s: unable to calc clk rate, %d\n", __func__
, ret
);
2188 ret
= dsi_host_regulator_enable(msm_host
);
2190 pr_err("%s:Failed to enable vregs.ret=%d\n",
2195 ret
= dsi_bus_clk_enable(msm_host
);
2197 pr_err("%s: failed to enable bus clocks, %d\n", __func__
, ret
);
2198 goto fail_disable_reg
;
2201 dsi_phy_sw_reset(msm_host
);
2202 ret
= msm_dsi_manager_phy_enable(msm_host
->id
,
2203 msm_host
->byte_clk_rate
* 8,
2204 msm_host
->esc_clk_rate
,
2205 &clk_pre
, &clk_post
);
2206 dsi_bus_clk_disable(msm_host
);
2208 pr_err("%s: failed to enable phy, %d\n", __func__
, ret
);
2209 goto fail_disable_reg
;
2212 ret
= dsi_clk_ctrl(msm_host
, 1);
2214 pr_err("%s: failed to enable clocks. ret=%d\n", __func__
, ret
);
2215 goto fail_disable_reg
;
2218 ret
= pinctrl_pm_select_default_state(&msm_host
->pdev
->dev
);
2220 pr_err("%s: failed to set pinctrl default state, %d\n",
2222 goto fail_disable_clk
;
2225 dsi_timing_setup(msm_host
);
2226 dsi_sw_reset(msm_host
);
2227 dsi_ctrl_config(msm_host
, true, clk_pre
, clk_post
);
2229 if (msm_host
->disp_en_gpio
)
2230 gpiod_set_value(msm_host
->disp_en_gpio
, 1);
2232 msm_host
->power_on
= true;
2233 mutex_unlock(&msm_host
->dev_mutex
);
2238 dsi_clk_ctrl(msm_host
, 0);
2240 dsi_host_regulator_disable(msm_host
);
2242 mutex_unlock(&msm_host
->dev_mutex
);
2246 int msm_dsi_host_power_off(struct mipi_dsi_host
*host
)
2248 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2250 mutex_lock(&msm_host
->dev_mutex
);
2251 if (!msm_host
->power_on
) {
2252 DBG("dsi host already off");
2256 dsi_ctrl_config(msm_host
, false, 0, 0);
2258 if (msm_host
->disp_en_gpio
)
2259 gpiod_set_value(msm_host
->disp_en_gpio
, 0);
2261 pinctrl_pm_select_sleep_state(&msm_host
->pdev
->dev
);
2263 msm_dsi_manager_phy_disable(msm_host
->id
);
2265 dsi_clk_ctrl(msm_host
, 0);
2267 dsi_host_regulator_disable(msm_host
);
2269 msm_dsi_sfpb_config(msm_host
, false);
2273 msm_host
->power_on
= false;
2276 mutex_unlock(&msm_host
->dev_mutex
);
2280 int msm_dsi_host_set_display_mode(struct mipi_dsi_host
*host
,
2281 struct drm_display_mode
*mode
)
2283 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2285 if (msm_host
->mode
) {
2286 drm_mode_destroy(msm_host
->dev
, msm_host
->mode
);
2287 msm_host
->mode
= NULL
;
2290 msm_host
->mode
= drm_mode_duplicate(msm_host
->dev
, mode
);
2291 if (!msm_host
->mode
) {
2292 pr_err("%s: cannot duplicate mode\n", __func__
);
2299 struct drm_panel
*msm_dsi_host_get_panel(struct mipi_dsi_host
*host
,
2300 unsigned long *panel_flags
)
2302 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2303 struct drm_panel
*panel
;
2305 panel
= of_drm_find_panel(msm_host
->device_node
);
2307 *panel_flags
= msm_host
->mode_flags
;
2312 struct drm_bridge
*msm_dsi_host_get_bridge(struct mipi_dsi_host
*host
)
2314 struct msm_dsi_host
*msm_host
= to_msm_dsi_host(host
);
2316 return of_drm_find_bridge(msm_host
->device_node
);