1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * tc358767 eDP bridge driver
5 * Copyright (C) 2016 CogentEmbedded Inc
6 * Author: Andrey Gusakov <andrey.gusakov@cogentembedded.com>
8 * Copyright (C) 2016 Pengutronix, Philipp Zabel <p.zabel@pengutronix.de>
10 * Copyright (C) 2016 Zodiac Inflight Innovations
12 * Initially based on: drivers/gpu/drm/i2c/tda998x_drv.c
14 * Copyright (C) 2012 Texas Instruments
15 * Author: Rob Clark <robdclark@gmail.com>
18 #include <linux/clk.h>
19 #include <linux/device.h>
20 #include <linux/gpio/consumer.h>
21 #include <linux/i2c.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/regmap.h>
25 #include <linux/slab.h>
27 #include <drm/drm_atomic_helper.h>
28 #include <drm/drm_dp_helper.h>
29 #include <drm/drm_edid.h>
30 #include <drm/drm_of.h>
31 #include <drm/drm_panel.h>
32 #include <drm/drm_probe_helper.h>
36 /* Display Parallel Interface */
37 #define DPIPXLFMT 0x0440
38 #define VS_POL_ACTIVE_LOW (1 << 10)
39 #define HS_POL_ACTIVE_LOW (1 << 9)
40 #define DE_POL_ACTIVE_HIGH (0 << 8)
41 #define SUB_CFG_TYPE_CONFIG1 (0 << 2) /* LSB aligned */
42 #define SUB_CFG_TYPE_CONFIG2 (1 << 2) /* Loosely Packed */
43 #define SUB_CFG_TYPE_CONFIG3 (2 << 2) /* LSB aligned 8-bit */
44 #define DPI_BPP_RGB888 (0 << 0)
45 #define DPI_BPP_RGB666 (1 << 0)
46 #define DPI_BPP_RGB565 (2 << 0)
49 #define VPCTRL0 0x0450
50 #define OPXLFMT_RGB666 (0 << 8)
51 #define OPXLFMT_RGB888 (1 << 8)
52 #define FRMSYNC_DISABLED (0 << 4) /* Video Timing Gen Disabled */
53 #define FRMSYNC_ENABLED (1 << 4) /* Video Timing Gen Enabled */
54 #define MSF_DISABLED (0 << 0) /* Magic Square FRC disabled */
55 #define MSF_ENABLED (1 << 0) /* Magic Square FRC enabled */
61 #define VFUEN BIT(0) /* Video Frame Timing Upload */
64 #define TC_IDREG 0x0500
65 #define SYSCTRL 0x0510
66 #define DP0_AUDSRC_NO_INPUT (0 << 3)
67 #define DP0_AUDSRC_I2S_RX (1 << 3)
68 #define DP0_VIDSRC_NO_INPUT (0 << 0)
69 #define DP0_VIDSRC_DSI_RX (1 << 0)
70 #define DP0_VIDSRC_DPI_RX (2 << 0)
71 #define DP0_VIDSRC_COLOR_BAR (3 << 0)
75 #define VID_MN_GEN BIT(6) /* Auto-generate M/N values */
76 #define EF_EN BIT(5) /* Enable Enhanced Framing */
77 #define VID_EN BIT(1) /* Video transmission enable */
78 #define DP_EN BIT(0) /* Enable DPTX function */
81 #define DP0_VIDMNGEN0 0x0610
82 #define DP0_VIDMNGEN1 0x0614
83 #define DP0_VMNGENSTATUS 0x0618
86 #define DP0_SECSAMPLE 0x0640
87 #define DP0_VIDSYNCDELAY 0x0644
88 #define DP0_TOTALVAL 0x0648
89 #define DP0_STARTVAL 0x064c
90 #define DP0_ACTIVEVAL 0x0650
91 #define DP0_SYNCVAL 0x0654
92 #define SYNCVAL_HS_POL_ACTIVE_LOW (1 << 15)
93 #define SYNCVAL_VS_POL_ACTIVE_LOW (1 << 31)
94 #define DP0_MISC 0x0658
95 #define TU_SIZE_RECOMMENDED (63) /* LSCLK cycles per TU */
96 #define BPC_6 (0 << 5)
97 #define BPC_8 (1 << 5)
100 #define DP0_AUXCFG0 0x0660
101 #define DP0_AUXCFG1 0x0664
102 #define AUX_RX_FILTER_EN BIT(16)
104 #define DP0_AUXADDR 0x0668
105 #define DP0_AUXWDATA(i) (0x066c + (i) * 4)
106 #define DP0_AUXRDATA(i) (0x067c + (i) * 4)
107 #define DP0_AUXSTATUS 0x068c
108 #define AUX_STATUS_MASK 0xf0
109 #define AUX_STATUS_SHIFT 4
110 #define AUX_TIMEOUT BIT(1)
111 #define AUX_BUSY BIT(0)
112 #define DP0_AUXI2CADR 0x0698
115 #define DP0_SRCCTRL 0x06a0
116 #define DP0_SRCCTRL_SCRMBLDIS BIT(13)
117 #define DP0_SRCCTRL_EN810B BIT(12)
118 #define DP0_SRCCTRL_NOTP (0 << 8)
119 #define DP0_SRCCTRL_TP1 (1 << 8)
120 #define DP0_SRCCTRL_TP2 (2 << 8)
121 #define DP0_SRCCTRL_LANESKEW BIT(7)
122 #define DP0_SRCCTRL_SSCG BIT(3)
123 #define DP0_SRCCTRL_LANES_1 (0 << 2)
124 #define DP0_SRCCTRL_LANES_2 (1 << 2)
125 #define DP0_SRCCTRL_BW27 (1 << 1)
126 #define DP0_SRCCTRL_BW162 (0 << 1)
127 #define DP0_SRCCTRL_AUTOCORRECT BIT(0)
128 #define DP0_LTSTAT 0x06d0
129 #define LT_LOOPDONE BIT(13)
130 #define LT_STATUS_MASK (0x1f << 8)
131 #define LT_CHANNEL1_EQ_BITS (DP_CHANNEL_EQ_BITS << 4)
132 #define LT_INTERLANE_ALIGN_DONE BIT(3)
133 #define LT_CHANNEL0_EQ_BITS (DP_CHANNEL_EQ_BITS)
134 #define DP0_SNKLTCHGREQ 0x06d4
135 #define DP0_LTLOOPCTRL 0x06d8
136 #define DP0_SNKLTCTRL 0x06e4
138 #define DP1_SRCCTRL 0x07a0
141 #define DP_PHY_CTRL 0x0800
142 #define DP_PHY_RST BIT(28) /* DP PHY Global Soft Reset */
143 #define BGREN BIT(25) /* AUX PHY BGR Enable */
144 #define PWR_SW_EN BIT(24) /* PHY Power Switch Enable */
145 #define PHY_M1_RST BIT(12) /* Reset PHY1 Main Channel */
146 #define PHY_RDY BIT(16) /* PHY Main Channels Ready */
147 #define PHY_M0_RST BIT(8) /* Reset PHY0 Main Channel */
148 #define PHY_2LANE BIT(2) /* PHY Enable 2 lanes */
149 #define PHY_A0_EN BIT(1) /* PHY Aux Channel0 Enable */
150 #define PHY_M0_EN BIT(0) /* PHY Main Channel0 Enable */
153 #define DP0_PLLCTRL 0x0900
154 #define DP1_PLLCTRL 0x0904 /* not defined in DS */
155 #define PXL_PLLCTRL 0x0908
156 #define PLLUPDATE BIT(2)
157 #define PLLBYP BIT(1)
159 #define PXL_PLLPARAM 0x0914
160 #define IN_SEL_REFCLK (0 << 14)
161 #define SYS_PLLPARAM 0x0918
162 #define REF_FREQ_38M4 (0 << 8) /* 38.4 MHz */
163 #define REF_FREQ_19M2 (1 << 8) /* 19.2 MHz */
164 #define REF_FREQ_26M (2 << 8) /* 26 MHz */
165 #define REF_FREQ_13M (3 << 8) /* 13 MHz */
166 #define SYSCLK_SEL_LSCLK (0 << 4)
167 #define LSCLK_DIV_1 (0 << 0)
168 #define LSCLK_DIV_2 (1 << 0)
171 #define TSTCTL 0x0a00
172 #define PLL_DBG 0x0a04
174 static bool tc_test_pattern
;
175 module_param_named(test
, tc_test_pattern
, bool, 0644);
178 struct drm_dp_link base
;
189 struct regmap
*regmap
;
190 struct drm_dp_aux aux
;
192 struct drm_bridge bridge
;
193 struct drm_connector connector
;
194 struct drm_panel
*panel
;
197 struct tc_edp_link link
;
202 const struct drm_display_mode
*mode
;
207 struct gpio_desc
*sd_gpio
;
208 struct gpio_desc
*reset_gpio
;
212 static inline struct tc_data
*aux_to_tc(struct drm_dp_aux
*a
)
214 return container_of(a
, struct tc_data
, aux
);
217 static inline struct tc_data
*bridge_to_tc(struct drm_bridge
*b
)
219 return container_of(b
, struct tc_data
, bridge
);
222 static inline struct tc_data
*connector_to_tc(struct drm_connector
*c
)
224 return container_of(c
, struct tc_data
, connector
);
227 /* Simple macros to avoid repeated error checks */
228 #define tc_write(reg, var) \
230 ret = regmap_write(tc->regmap, reg, var); \
234 #define tc_read(reg, var) \
236 ret = regmap_read(tc->regmap, reg, var); \
241 static inline int tc_poll_timeout(struct regmap
*map
, unsigned int addr
,
242 unsigned int cond_mask
,
243 unsigned int cond_value
,
244 unsigned long sleep_us
, u64 timeout_us
)
246 ktime_t timeout
= ktime_add_us(ktime_get(), timeout_us
);
251 ret
= regmap_read(map
, addr
, &val
);
254 if ((val
& cond_mask
) == cond_value
)
256 if (timeout_us
&& ktime_compare(ktime_get(), timeout
) > 0) {
257 ret
= regmap_read(map
, addr
, &val
);
261 usleep_range((sleep_us
>> 2) + 1, sleep_us
);
263 return ret
?: (((val
& cond_mask
) == cond_value
) ? 0 : -ETIMEDOUT
);
266 static int tc_aux_wait_busy(struct tc_data
*tc
, unsigned int timeout_ms
)
268 return tc_poll_timeout(tc
->regmap
, DP0_AUXSTATUS
, AUX_BUSY
, 0,
269 1000, 1000 * timeout_ms
);
272 static int tc_aux_get_status(struct tc_data
*tc
, u8
*reply
)
277 ret
= regmap_read(tc
->regmap
, DP0_AUXSTATUS
, &value
);
280 if (value
& AUX_BUSY
) {
281 if (value
& AUX_TIMEOUT
) {
282 dev_err(tc
->dev
, "i2c access timeout!\n");
288 *reply
= (value
& AUX_STATUS_MASK
) >> AUX_STATUS_SHIFT
;
292 static ssize_t
tc_aux_transfer(struct drm_dp_aux
*aux
,
293 struct drm_dp_aux_msg
*msg
)
295 struct tc_data
*tc
= aux_to_tc(aux
);
296 size_t size
= min_t(size_t, 8, msg
->size
);
297 u8 request
= msg
->request
& ~DP_AUX_I2C_MOT
;
298 u8
*buf
= msg
->buffer
;
306 ret
= tc_aux_wait_busy(tc
, 100);
310 if (request
== DP_AUX_I2C_WRITE
|| request
== DP_AUX_NATIVE_WRITE
) {
313 if (request
== DP_AUX_NATIVE_WRITE
)
314 tmp
= tmp
| (buf
[i
] << (8 * (i
& 0x3)));
316 tmp
= (tmp
<< 8) | buf
[i
];
318 if (((i
% 4) == 0) || (i
== size
)) {
319 tc_write(DP0_AUXWDATA((i
- 1) >> 2), tmp
);
323 } else if (request
!= DP_AUX_I2C_READ
&&
324 request
!= DP_AUX_NATIVE_READ
) {
329 tc_write(DP0_AUXADDR
, msg
->address
);
331 tc_write(DP0_AUXCFG0
, ((size
- 1) << 8) | request
);
333 ret
= tc_aux_wait_busy(tc
, 100);
337 ret
= tc_aux_get_status(tc
, &msg
->reply
);
341 if (request
== DP_AUX_I2C_READ
|| request
== DP_AUX_NATIVE_READ
) {
345 tc_read(DP0_AUXRDATA(i
>> 2), &tmp
);
357 static const char * const training_pattern1_errors
[] = {
361 "Max voltage reached error",
362 "Loop counter expired error",
366 static const char * const training_pattern2_errors
[] = {
370 "Clock recovery failed error",
371 "Loop counter expired error",
375 static u32
tc_srcctrl(struct tc_data
*tc
)
378 * No training pattern, skew lane 1 data by two LSCLK cycles with
379 * respect to lane 0 data, AutoCorrect Mode = 0
381 u32 reg
= DP0_SRCCTRL_NOTP
| DP0_SRCCTRL_LANESKEW
;
383 if (tc
->link
.scrambler_dis
)
384 reg
|= DP0_SRCCTRL_SCRMBLDIS
; /* Scrambler Disabled */
385 if (tc
->link
.coding8b10b
)
386 /* Enable 8/10B Encoder (TxData[19:16] not used) */
387 reg
|= DP0_SRCCTRL_EN810B
;
389 reg
|= DP0_SRCCTRL_SSCG
; /* Spread Spectrum Enable */
390 if (tc
->link
.base
.num_lanes
== 2)
391 reg
|= DP0_SRCCTRL_LANES_2
; /* Two Main Channel Lanes */
392 if (tc
->link
.base
.rate
!= 162000)
393 reg
|= DP0_SRCCTRL_BW27
; /* 2.7 Gbps link */
397 static void tc_wait_pll_lock(struct tc_data
*tc
)
399 /* Wait for PLL to lock: up to 2.09 ms, depending on refclk */
400 usleep_range(3000, 6000);
403 static int tc_pxl_pll_en(struct tc_data
*tc
, u32 refclk
, u32 pixelclock
)
406 int i_pre
, best_pre
= 1;
407 int i_post
, best_post
= 1;
408 int div
, best_div
= 1;
409 int mul
, best_mul
= 1;
410 int delta
, best_delta
;
411 int ext_div
[] = {1, 2, 3, 5, 7};
412 int best_pixelclock
= 0;
415 dev_dbg(tc
->dev
, "PLL: requested %d pixelclock, ref %d\n", pixelclock
,
417 best_delta
= pixelclock
;
418 /* Loop over all possible ext_divs, skipping invalid configurations */
419 for (i_pre
= 0; i_pre
< ARRAY_SIZE(ext_div
); i_pre
++) {
421 * refclk / ext_pre_div should be in the 1 to 200 MHz range.
422 * We don't allow any refclk > 200 MHz, only check lower bounds.
424 if (refclk
/ ext_div
[i_pre
] < 1000000)
426 for (i_post
= 0; i_post
< ARRAY_SIZE(ext_div
); i_post
++) {
427 for (div
= 1; div
<= 16; div
++) {
431 tmp
= pixelclock
* ext_div
[i_pre
] *
432 ext_div
[i_post
] * div
;
437 if ((mul
< 1) || (mul
> 128))
440 clk
= (refclk
/ ext_div
[i_pre
] / div
) * mul
;
442 * refclk * mul / (ext_pre_div * pre_div)
443 * should be in the 150 to 650 MHz range
445 if ((clk
> 650000000) || (clk
< 150000000))
448 clk
= clk
/ ext_div
[i_post
];
449 delta
= clk
- pixelclock
;
451 if (abs(delta
) < abs(best_delta
)) {
457 best_pixelclock
= clk
;
462 if (best_pixelclock
== 0) {
463 dev_err(tc
->dev
, "Failed to calc clock for %d pixelclock\n",
468 dev_dbg(tc
->dev
, "PLL: got %d, delta %d\n", best_pixelclock
,
470 dev_dbg(tc
->dev
, "PLL: %d / %d / %d * %d / %d\n", refclk
,
471 ext_div
[best_pre
], best_div
, best_mul
, ext_div
[best_post
]);
473 /* if VCO >= 300 MHz */
474 if (refclk
/ ext_div
[best_pre
] / best_div
* best_mul
>= 300000000)
482 /* Power up PLL and switch to bypass */
483 tc_write(PXL_PLLCTRL
, PLLBYP
| PLLEN
);
485 tc_write(PXL_PLLPARAM
,
486 (vco_hi
<< 24) | /* For PLL VCO >= 300 MHz = 1 */
487 (ext_div
[best_pre
] << 20) | /* External Pre-divider */
488 (ext_div
[best_post
] << 16) | /* External Post-divider */
489 IN_SEL_REFCLK
| /* Use RefClk as PLL input */
490 (best_div
<< 8) | /* Divider for PLL RefClk */
491 (best_mul
<< 0)); /* Multiplier for PLL */
493 /* Force PLL parameter update and disable bypass */
494 tc_write(PXL_PLLCTRL
, PLLUPDATE
| PLLEN
);
496 tc_wait_pll_lock(tc
);
503 static int tc_pxl_pll_dis(struct tc_data
*tc
)
505 /* Enable PLL bypass, power down PLL */
506 return regmap_write(tc
->regmap
, PXL_PLLCTRL
, PLLBYP
);
509 static int tc_stream_clock_calc(struct tc_data
*tc
)
513 * If the Stream clock and Link Symbol clock are
514 * asynchronous with each other, the value of M changes over
515 * time. This way of generating link clock and stream
516 * clock is called Asynchronous Clock mode. The value M
517 * must change while the value N stays constant. The
518 * value of N in this Asynchronous Clock mode must be set
521 * LSCLK = 1/10 of high speed link clock
523 * f_STRMCLK = M/N * f_LSCLK
524 * M/N = f_STRMCLK / f_LSCLK
527 tc_write(DP0_VIDMNGEN1
, 32768);
534 static int tc_aux_link_setup(struct tc_data
*tc
)
541 rate
= clk_get_rate(tc
->refclk
);
544 value
= REF_FREQ_38M4
;
547 value
= REF_FREQ_26M
;
550 value
= REF_FREQ_19M2
;
553 value
= REF_FREQ_13M
;
556 dev_err(tc
->dev
, "Invalid refclk rate: %lu Hz\n", rate
);
560 /* Setup DP-PHY / PLL */
561 value
|= SYSCLK_SEL_LSCLK
| LSCLK_DIV_2
;
562 tc_write(SYS_PLLPARAM
, value
);
564 dp_phy_ctrl
= BGREN
| PWR_SW_EN
| PHY_A0_EN
;
565 if (tc
->link
.base
.num_lanes
== 2)
566 dp_phy_ctrl
|= PHY_2LANE
;
567 tc_write(DP_PHY_CTRL
, dp_phy_ctrl
);
570 * Initially PLLs are in bypass. Force PLL parameter update,
571 * disable PLL bypass, enable PLL
573 tc_write(DP0_PLLCTRL
, PLLUPDATE
| PLLEN
);
574 tc_wait_pll_lock(tc
);
576 tc_write(DP1_PLLCTRL
, PLLUPDATE
| PLLEN
);
577 tc_wait_pll_lock(tc
);
579 ret
= tc_poll_timeout(tc
->regmap
, DP_PHY_CTRL
, PHY_RDY
, PHY_RDY
, 1,
581 if (ret
== -ETIMEDOUT
) {
582 dev_err(tc
->dev
, "Timeout waiting for PHY to become ready");
588 tc_write(DP0_AUXCFG1
, AUX_RX_FILTER_EN
|
589 (0x06 << 8) | /* Aux Bit Period Calculator Threshold */
590 (0x3f << 0)); /* Aux Response Timeout Timer */
594 dev_err(tc
->dev
, "tc_aux_link_setup failed: %d\n", ret
);
598 static int tc_get_display_props(struct tc_data
*tc
)
604 /* Read DP Rx Link Capability */
605 ret
= drm_dp_link_probe(&tc
->aux
, &tc
->link
.base
);
608 if (tc
->link
.base
.rate
!= 162000 && tc
->link
.base
.rate
!= 270000) {
609 dev_dbg(tc
->dev
, "Falling to 2.7 Gbps rate\n");
610 tc
->link
.base
.rate
= 270000;
613 if (tc
->link
.base
.num_lanes
> 2) {
614 dev_dbg(tc
->dev
, "Falling to 2 lanes\n");
615 tc
->link
.base
.num_lanes
= 2;
618 ret
= drm_dp_dpcd_readb(&tc
->aux
, DP_MAX_DOWNSPREAD
, tmp
);
621 tc
->link
.spread
= tmp
[0] & BIT(0); /* 0.5% down spread */
623 ret
= drm_dp_dpcd_readb(&tc
->aux
, DP_MAIN_LINK_CHANNEL_CODING
, tmp
);
626 tc
->link
.coding8b10b
= tmp
[0] & BIT(0);
627 tc
->link
.scrambler_dis
= 0;
629 ret
= drm_dp_dpcd_readb(&tc
->aux
, DP_EDP_CONFIGURATION_SET
, tmp
);
632 tc
->link
.assr
= tmp
[0] & DP_ALTERNATE_SCRAMBLER_RESET_ENABLE
;
634 dev_dbg(tc
->dev
, "DPCD rev: %d.%d, rate: %s, lanes: %d, framing: %s\n",
635 tc
->link
.base
.revision
>> 4, tc
->link
.base
.revision
& 0x0f,
636 (tc
->link
.base
.rate
== 162000) ? "1.62Gbps" : "2.7Gbps",
637 tc
->link
.base
.num_lanes
,
638 (tc
->link
.base
.capabilities
& DP_LINK_CAP_ENHANCED_FRAMING
) ?
639 "enhanced" : "non-enhanced");
640 dev_dbg(tc
->dev
, "ANSI 8B/10B: %d\n", tc
->link
.coding8b10b
);
641 dev_dbg(tc
->dev
, "Display ASSR: %d, TC358767 ASSR: %d\n",
642 tc
->link
.assr
, tc
->assr
);
647 dev_err(tc
->dev
, "failed to read DPCD: %d\n", ret
);
651 static int tc_set_video_mode(struct tc_data
*tc
,
652 const struct drm_display_mode
*mode
)
658 int left_margin
= mode
->htotal
- mode
->hsync_end
;
659 int right_margin
= mode
->hsync_start
- mode
->hdisplay
;
660 int hsync_len
= mode
->hsync_end
- mode
->hsync_start
;
661 int upper_margin
= mode
->vtotal
- mode
->vsync_end
;
662 int lower_margin
= mode
->vsync_start
- mode
->vdisplay
;
663 int vsync_len
= mode
->vsync_end
- mode
->vsync_start
;
666 * Recommended maximum number of symbols transferred in a transfer unit:
667 * DIV_ROUND_UP((input active video bandwidth in bytes) * tu_size,
668 * (output active video bandwidth in bytes))
669 * Must be less than tu_size.
671 max_tu_symbol
= TU_SIZE_RECOMMENDED
- 1;
673 dev_dbg(tc
->dev
, "set mode %dx%d\n",
674 mode
->hdisplay
, mode
->vdisplay
);
675 dev_dbg(tc
->dev
, "H margin %d,%d sync %d\n",
676 left_margin
, right_margin
, hsync_len
);
677 dev_dbg(tc
->dev
, "V margin %d,%d sync %d\n",
678 upper_margin
, lower_margin
, vsync_len
);
679 dev_dbg(tc
->dev
, "total: %dx%d\n", mode
->htotal
, mode
->vtotal
);
684 * datasheet is not clear of vsdelay in case of DPI
685 * assume we do not need any delay when DPI is a source of
688 tc_write(VPCTRL0
, (0 << 20) /* VSDELAY */ |
689 OPXLFMT_RGB888
| FRMSYNC_DISABLED
| MSF_DISABLED
);
690 tc_write(HTIM01
, (ALIGN(left_margin
, 2) << 16) | /* H back porch */
691 (ALIGN(hsync_len
, 2) << 0)); /* Hsync */
692 tc_write(HTIM02
, (ALIGN(right_margin
, 2) << 16) | /* H front porch */
693 (ALIGN(mode
->hdisplay
, 2) << 0)); /* width */
694 tc_write(VTIM01
, (upper_margin
<< 16) | /* V back porch */
695 (vsync_len
<< 0)); /* Vsync */
696 tc_write(VTIM02
, (lower_margin
<< 16) | /* V front porch */
697 (mode
->vdisplay
<< 0)); /* height */
698 tc_write(VFUEN0
, VFUEN
); /* update settings */
700 /* Test pattern settings */
702 (120 << 24) | /* Red Color component value */
703 (20 << 16) | /* Green Color component value */
704 (99 << 8) | /* Blue Color component value */
705 (1 << 4) | /* Enable I2C Filter */
706 (2 << 0) | /* Color bar Mode */
709 /* DP Main Stream Attributes */
710 vid_sync_dly
= hsync_len
+ left_margin
+ mode
->hdisplay
;
711 tc_write(DP0_VIDSYNCDELAY
,
712 (max_tu_symbol
<< 16) | /* thresh_dly */
713 (vid_sync_dly
<< 0));
715 tc_write(DP0_TOTALVAL
, (mode
->vtotal
<< 16) | (mode
->htotal
));
717 tc_write(DP0_STARTVAL
,
718 ((upper_margin
+ vsync_len
) << 16) |
719 ((left_margin
+ hsync_len
) << 0));
721 tc_write(DP0_ACTIVEVAL
, (mode
->vdisplay
<< 16) | (mode
->hdisplay
));
723 tc_write(DP0_SYNCVAL
, (vsync_len
<< 16) | (hsync_len
<< 0) |
724 ((mode
->flags
& DRM_MODE_FLAG_NHSYNC
) ? SYNCVAL_HS_POL_ACTIVE_LOW
: 0) |
725 ((mode
->flags
& DRM_MODE_FLAG_NVSYNC
) ? SYNCVAL_VS_POL_ACTIVE_LOW
: 0));
727 tc_write(DPIPXLFMT
, VS_POL_ACTIVE_LOW
| HS_POL_ACTIVE_LOW
|
728 DE_POL_ACTIVE_HIGH
| SUB_CFG_TYPE_CONFIG1
| DPI_BPP_RGB888
);
730 tc_write(DP0_MISC
, (max_tu_symbol
<< 23) | (TU_SIZE_RECOMMENDED
<< 16) |
738 static int tc_link_training(struct tc_data
*tc
, int pattern
)
740 const char * const *errors
;
741 u32 srcctrl
= tc_srcctrl(tc
) | DP0_SRCCTRL_SCRMBLDIS
|
742 DP0_SRCCTRL_AUTOCORRECT
;
748 if (pattern
== DP_TRAINING_PATTERN_1
) {
749 srcctrl
|= DP0_SRCCTRL_TP1
;
750 errors
= training_pattern1_errors
;
752 srcctrl
|= DP0_SRCCTRL_TP2
;
753 errors
= training_pattern2_errors
;
756 /* Set DPCD 0x102 for Training Part 1 or 2 */
757 tc_write(DP0_SNKLTCTRL
, DP_LINK_SCRAMBLING_DISABLE
| pattern
);
759 tc_write(DP0_LTLOOPCTRL
,
760 (0x0f << 28) | /* Defer Iteration Count */
761 (0x0f << 24) | /* Loop Iteration Count */
762 (0x0d << 0)); /* Loop Timer Delay */
766 /* Set DP0 Training Pattern */
767 tc_write(DP0_SRCCTRL
, srcctrl
);
769 /* Enable DP0 to start Link Training */
770 tc_write(DP0CTL
, DP_EN
);
775 tc_read(DP0_LTSTAT
, &value
);
777 } while ((!(value
& LT_LOOPDONE
)) && (--timeout
));
779 dev_err(tc
->dev
, "Link training timeout!\n");
781 int pattern
= (value
>> 11) & 0x3;
782 int error
= (value
>> 8) & 0x7;
785 "Link training phase %d done after %d uS: %s\n",
786 pattern
, 1000 - timeout
, errors
[error
]);
787 if (pattern
== DP_TRAINING_PATTERN_1
&& error
== 0)
789 if (pattern
== DP_TRAINING_PATTERN_2
) {
790 value
&= LT_CHANNEL1_EQ_BITS
|
791 LT_INTERLANE_ALIGN_DONE
|
793 /* in case of two lanes */
794 if ((tc
->link
.base
.num_lanes
== 2) &&
795 (value
== (LT_CHANNEL1_EQ_BITS
|
796 LT_INTERLANE_ALIGN_DONE
|
797 LT_CHANNEL0_EQ_BITS
)))
799 /* in case of one line */
800 if ((tc
->link
.base
.num_lanes
== 1) &&
801 (value
== (LT_INTERLANE_ALIGN_DONE
|
802 LT_CHANNEL0_EQ_BITS
)))
808 usleep_range(10, 20);
811 dev_err(tc
->dev
, "Failed to finish training phase %d\n",
820 static int tc_main_link_setup(struct tc_data
*tc
)
822 struct drm_dp_aux
*aux
= &tc
->aux
;
823 struct device
*dev
= tc
->dev
;
831 /* display mode should be set at this point */
835 tc_write(DP0_SRCCTRL
, tc_srcctrl(tc
));
836 /* SSCG and BW27 on DP1 must be set to the same as on DP0 */
837 tc_write(DP1_SRCCTRL
,
838 (tc
->link
.spread
? DP0_SRCCTRL_SSCG
: 0) |
839 ((tc
->link
.base
.rate
!= 162000) ? DP0_SRCCTRL_BW27
: 0));
841 rate
= clk_get_rate(tc
->refclk
);
844 value
= REF_FREQ_38M4
;
847 value
= REF_FREQ_26M
;
850 value
= REF_FREQ_19M2
;
853 value
= REF_FREQ_13M
;
858 value
|= SYSCLK_SEL_LSCLK
| LSCLK_DIV_2
;
859 tc_write(SYS_PLLPARAM
, value
);
861 /* Setup Main Link */
862 dp_phy_ctrl
= BGREN
| PWR_SW_EN
| PHY_A0_EN
| PHY_M0_EN
;
863 if (tc
->link
.base
.num_lanes
== 2)
864 dp_phy_ctrl
|= PHY_2LANE
;
865 tc_write(DP_PHY_CTRL
, dp_phy_ctrl
);
869 tc_write(DP0_PLLCTRL
, PLLUPDATE
| PLLEN
);
870 tc_wait_pll_lock(tc
);
872 tc_write(DP1_PLLCTRL
, PLLUPDATE
| PLLEN
);
873 tc_wait_pll_lock(tc
);
876 if (tc_test_pattern
) {
877 ret
= tc_pxl_pll_en(tc
, clk_get_rate(tc
->refclk
),
878 1000 * tc
->mode
->clock
);
883 /* Reset/Enable Main Links */
884 dp_phy_ctrl
|= DP_PHY_RST
| PHY_M1_RST
| PHY_M0_RST
;
885 tc_write(DP_PHY_CTRL
, dp_phy_ctrl
);
886 usleep_range(100, 200);
887 dp_phy_ctrl
&= ~(DP_PHY_RST
| PHY_M1_RST
| PHY_M0_RST
);
888 tc_write(DP_PHY_CTRL
, dp_phy_ctrl
);
892 tc_read(DP_PHY_CTRL
, &value
);
894 } while ((!(value
& PHY_RDY
)) && (--timeout
));
897 dev_err(dev
, "timeout waiting for phy become ready");
901 /* Set misc: 8 bits per color */
902 ret
= regmap_update_bits(tc
->regmap
, DP0_MISC
, BPC_8
, BPC_8
);
908 * on TC358767 side ASSR configured through strap pin
909 * seems there is no way to change this setting from SW
911 * check is tc configured for same mode
913 if (tc
->assr
!= tc
->link
.assr
) {
914 dev_dbg(dev
, "Trying to set display to ASSR: %d\n",
916 /* try to set ASSR on display side */
918 ret
= drm_dp_dpcd_writeb(aux
, DP_EDP_CONFIGURATION_SET
, tmp
[0]);
922 ret
= drm_dp_dpcd_readb(aux
, DP_EDP_CONFIGURATION_SET
, tmp
);
926 if (tmp
[0] != tc
->assr
) {
927 dev_dbg(dev
, "Failed to switch display ASSR to %d, falling back to unscrambled mode\n",
929 /* trying with disabled scrambler */
930 tc
->link
.scrambler_dis
= 1;
934 /* Setup Link & DPRx Config for Training */
935 ret
= drm_dp_link_configure(aux
, &tc
->link
.base
);
939 /* DOWNSPREAD_CTRL */
940 tmp
[0] = tc
->link
.spread
? DP_SPREAD_AMP_0_5
: 0x00;
941 /* MAIN_LINK_CHANNEL_CODING_SET */
942 tmp
[1] = tc
->link
.coding8b10b
? DP_SET_ANSI_8B10B
: 0x00;
943 ret
= drm_dp_dpcd_write(aux
, DP_DOWNSPREAD_CTRL
, tmp
, 2);
947 ret
= tc_link_training(tc
, DP_TRAINING_PATTERN_1
);
951 ret
= tc_link_training(tc
, DP_TRAINING_PATTERN_2
);
955 /* Clear DPCD 0x102 */
956 /* Note: Can Not use DP0_SNKLTCTRL (0x06E4) short cut */
957 tmp
[0] = tc
->link
.scrambler_dis
? DP_LINK_SCRAMBLING_DISABLE
: 0x00;
958 ret
= drm_dp_dpcd_writeb(aux
, DP_TRAINING_PATTERN_SET
, tmp
[0]);
962 /* Clear Training Pattern, set AutoCorrect Mode = 1 */
963 tc_write(DP0_SRCCTRL
, tc_srcctrl(tc
) | DP0_SRCCTRL_AUTOCORRECT
);
969 /* Read DPCD 0x202-0x207 */
970 ret
= drm_dp_dpcd_read_link_status(aux
, tmp
+ 2);
973 } while ((--timeout
) &&
974 !(drm_dp_channel_eq_ok(tmp
+ 2, tc
->link
.base
.num_lanes
)));
977 /* Read DPCD 0x200-0x201 */
978 ret
= drm_dp_dpcd_read(aux
, DP_SINK_COUNT
, tmp
, 2);
981 dev_err(dev
, "channel(s) EQ not ok\n");
982 dev_info(dev
, "0x0200 SINK_COUNT: 0x%02x\n", tmp
[0]);
983 dev_info(dev
, "0x0201 DEVICE_SERVICE_IRQ_VECTOR: 0x%02x\n",
985 dev_info(dev
, "0x0202 LANE0_1_STATUS: 0x%02x\n", tmp
[2]);
986 dev_info(dev
, "0x0204 LANE_ALIGN_STATUS_UPDATED: 0x%02x\n",
988 dev_info(dev
, "0x0205 SINK_STATUS: 0x%02x\n", tmp
[5]);
989 dev_info(dev
, "0x0206 ADJUST_REQUEST_LANE0_1: 0x%02x\n",
995 ret
= tc_set_video_mode(tc
, tc
->mode
);
1000 ret
= tc_stream_clock_calc(tc
);
1006 dev_err(tc
->dev
, "Failed to read DPCD: %d\n", ret
);
1009 dev_err(tc
->dev
, "Failed to write DPCD: %d\n", ret
);
1014 static int tc_main_link_stream(struct tc_data
*tc
, int state
)
1019 dev_dbg(tc
->dev
, "stream: %d\n", state
);
1022 value
= VID_MN_GEN
| DP_EN
;
1023 if (tc
->link
.base
.capabilities
& DP_LINK_CAP_ENHANCED_FRAMING
)
1025 tc_write(DP0CTL
, value
);
1027 * VID_EN assertion should be delayed by at least N * LSCLK
1028 * cycles from the time VID_MN_GEN is enabled in order to
1029 * generate stable values for VID_M. LSCLK is 270 MHz or
1030 * 162 MHz, VID_N is set to 32768 in tc_stream_clock_calc(),
1031 * so a delay of at least 203 us should suffice.
1033 usleep_range(500, 1000);
1035 tc_write(DP0CTL
, value
);
1036 /* Set input interface */
1037 value
= DP0_AUDSRC_NO_INPUT
;
1038 if (tc_test_pattern
)
1039 value
|= DP0_VIDSRC_COLOR_BAR
;
1041 value
|= DP0_VIDSRC_DPI_RX
;
1042 tc_write(SYSCTRL
, value
);
1044 tc_write(DP0CTL
, 0);
1052 static void tc_bridge_pre_enable(struct drm_bridge
*bridge
)
1054 struct tc_data
*tc
= bridge_to_tc(bridge
);
1056 drm_panel_prepare(tc
->panel
);
1059 static void tc_bridge_enable(struct drm_bridge
*bridge
)
1061 struct tc_data
*tc
= bridge_to_tc(bridge
);
1064 ret
= tc_main_link_setup(tc
);
1066 dev_err(tc
->dev
, "main link setup error: %d\n", ret
);
1070 ret
= tc_main_link_stream(tc
, 1);
1072 dev_err(tc
->dev
, "main link stream start error: %d\n", ret
);
1076 drm_panel_enable(tc
->panel
);
1079 static void tc_bridge_disable(struct drm_bridge
*bridge
)
1081 struct tc_data
*tc
= bridge_to_tc(bridge
);
1084 drm_panel_disable(tc
->panel
);
1086 ret
= tc_main_link_stream(tc
, 0);
1088 dev_err(tc
->dev
, "main link stream stop error: %d\n", ret
);
1091 static void tc_bridge_post_disable(struct drm_bridge
*bridge
)
1093 struct tc_data
*tc
= bridge_to_tc(bridge
);
1095 drm_panel_unprepare(tc
->panel
);
1098 static bool tc_bridge_mode_fixup(struct drm_bridge
*bridge
,
1099 const struct drm_display_mode
*mode
,
1100 struct drm_display_mode
*adj
)
1102 /* Fixup sync polarities, both hsync and vsync are active low */
1103 adj
->flags
= mode
->flags
;
1104 adj
->flags
|= (DRM_MODE_FLAG_NHSYNC
| DRM_MODE_FLAG_NVSYNC
);
1105 adj
->flags
&= ~(DRM_MODE_FLAG_PHSYNC
| DRM_MODE_FLAG_PVSYNC
);
1110 static enum drm_mode_status
tc_connector_mode_valid(struct drm_connector
*connector
,
1111 struct drm_display_mode
*mode
)
1113 struct tc_data
*tc
= connector_to_tc(connector
);
1115 u32 bits_per_pixel
= 24;
1117 /* DPI interface clock limitation: upto 154 MHz */
1118 if (mode
->clock
> 154000)
1119 return MODE_CLOCK_HIGH
;
1121 req
= mode
->clock
* bits_per_pixel
/ 8;
1122 avail
= tc
->link
.base
.num_lanes
* tc
->link
.base
.rate
;
1130 static void tc_bridge_mode_set(struct drm_bridge
*bridge
,
1131 const struct drm_display_mode
*mode
,
1132 const struct drm_display_mode
*adj
)
1134 struct tc_data
*tc
= bridge_to_tc(bridge
);
1139 static int tc_connector_get_modes(struct drm_connector
*connector
)
1141 struct tc_data
*tc
= connector_to_tc(connector
);
1145 if (tc
->panel
&& tc
->panel
->funcs
&& tc
->panel
->funcs
->get_modes
) {
1146 count
= tc
->panel
->funcs
->get_modes(tc
->panel
);
1151 edid
= drm_get_edid(connector
, &tc
->aux
.ddc
);
1158 drm_connector_update_edid_property(connector
, edid
);
1159 count
= drm_add_edid_modes(connector
, edid
);
1164 static void tc_connector_set_polling(struct tc_data
*tc
,
1165 struct drm_connector
*connector
)
1167 /* TODO: add support for HPD */
1168 connector
->polled
= DRM_CONNECTOR_POLL_CONNECT
|
1169 DRM_CONNECTOR_POLL_DISCONNECT
;
1172 static struct drm_encoder
*
1173 tc_connector_best_encoder(struct drm_connector
*connector
)
1175 struct tc_data
*tc
= connector_to_tc(connector
);
1177 return tc
->bridge
.encoder
;
1180 static const struct drm_connector_helper_funcs tc_connector_helper_funcs
= {
1181 .get_modes
= tc_connector_get_modes
,
1182 .mode_valid
= tc_connector_mode_valid
,
1183 .best_encoder
= tc_connector_best_encoder
,
1186 static const struct drm_connector_funcs tc_connector_funcs
= {
1187 .fill_modes
= drm_helper_probe_single_connector_modes
,
1188 .destroy
= drm_connector_cleanup
,
1189 .reset
= drm_atomic_helper_connector_reset
,
1190 .atomic_duplicate_state
= drm_atomic_helper_connector_duplicate_state
,
1191 .atomic_destroy_state
= drm_atomic_helper_connector_destroy_state
,
1194 static int tc_bridge_attach(struct drm_bridge
*bridge
)
1196 u32 bus_format
= MEDIA_BUS_FMT_RGB888_1X24
;
1197 struct tc_data
*tc
= bridge_to_tc(bridge
);
1198 struct drm_device
*drm
= bridge
->dev
;
1201 /* Create eDP connector */
1202 drm_connector_helper_add(&tc
->connector
, &tc_connector_helper_funcs
);
1203 ret
= drm_connector_init(drm
, &tc
->connector
, &tc_connector_funcs
,
1204 tc
->panel
? DRM_MODE_CONNECTOR_eDP
:
1205 DRM_MODE_CONNECTOR_DisplayPort
);
1210 drm_panel_attach(tc
->panel
, &tc
->connector
);
1212 drm_display_info_set_bus_formats(&tc
->connector
.display_info
,
1214 tc
->connector
.display_info
.bus_flags
=
1215 DRM_BUS_FLAG_DE_HIGH
|
1216 DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE
|
1217 DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE
;
1218 drm_connector_attach_encoder(&tc
->connector
, tc
->bridge
.encoder
);
1223 static const struct drm_bridge_funcs tc_bridge_funcs
= {
1224 .attach
= tc_bridge_attach
,
1225 .mode_set
= tc_bridge_mode_set
,
1226 .pre_enable
= tc_bridge_pre_enable
,
1227 .enable
= tc_bridge_enable
,
1228 .disable
= tc_bridge_disable
,
1229 .post_disable
= tc_bridge_post_disable
,
1230 .mode_fixup
= tc_bridge_mode_fixup
,
1233 static bool tc_readable_reg(struct device
*dev
, unsigned int reg
)
1235 return reg
!= SYSCTRL
;
1238 static const struct regmap_range tc_volatile_ranges
[] = {
1239 regmap_reg_range(DP0_AUXWDATA(0), DP0_AUXSTATUS
),
1240 regmap_reg_range(DP0_LTSTAT
, DP0_SNKLTCHGREQ
),
1241 regmap_reg_range(DP_PHY_CTRL
, DP_PHY_CTRL
),
1242 regmap_reg_range(DP0_PLLCTRL
, PXL_PLLCTRL
),
1243 regmap_reg_range(VFUEN0
, VFUEN0
),
1246 static const struct regmap_access_table tc_volatile_table
= {
1247 .yes_ranges
= tc_volatile_ranges
,
1248 .n_yes_ranges
= ARRAY_SIZE(tc_volatile_ranges
),
1251 static bool tc_writeable_reg(struct device
*dev
, unsigned int reg
)
1253 return (reg
!= TC_IDREG
) &&
1254 (reg
!= DP0_LTSTAT
) &&
1255 (reg
!= DP0_SNKLTCHGREQ
);
1258 static const struct regmap_config tc_regmap_config
= {
1263 .max_register
= PLL_DBG
,
1264 .cache_type
= REGCACHE_RBTREE
,
1265 .readable_reg
= tc_readable_reg
,
1266 .volatile_table
= &tc_volatile_table
,
1267 .writeable_reg
= tc_writeable_reg
,
1268 .reg_format_endian
= REGMAP_ENDIAN_BIG
,
1269 .val_format_endian
= REGMAP_ENDIAN_LITTLE
,
1272 static int tc_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
1274 struct device
*dev
= &client
->dev
;
1278 tc
= devm_kzalloc(dev
, sizeof(*tc
), GFP_KERNEL
);
1284 /* port@2 is the output port */
1285 ret
= drm_of_find_panel_or_bridge(dev
->of_node
, 2, 0, &tc
->panel
, NULL
);
1286 if (ret
&& ret
!= -ENODEV
)
1289 /* Shut down GPIO is optional */
1290 tc
->sd_gpio
= devm_gpiod_get_optional(dev
, "shutdown", GPIOD_OUT_HIGH
);
1291 if (IS_ERR(tc
->sd_gpio
))
1292 return PTR_ERR(tc
->sd_gpio
);
1295 gpiod_set_value_cansleep(tc
->sd_gpio
, 0);
1296 usleep_range(5000, 10000);
1299 /* Reset GPIO is optional */
1300 tc
->reset_gpio
= devm_gpiod_get_optional(dev
, "reset", GPIOD_OUT_LOW
);
1301 if (IS_ERR(tc
->reset_gpio
))
1302 return PTR_ERR(tc
->reset_gpio
);
1304 if (tc
->reset_gpio
) {
1305 gpiod_set_value_cansleep(tc
->reset_gpio
, 1);
1306 usleep_range(5000, 10000);
1309 tc
->refclk
= devm_clk_get(dev
, "ref");
1310 if (IS_ERR(tc
->refclk
)) {
1311 ret
= PTR_ERR(tc
->refclk
);
1312 dev_err(dev
, "Failed to get refclk: %d\n", ret
);
1316 tc
->regmap
= devm_regmap_init_i2c(client
, &tc_regmap_config
);
1317 if (IS_ERR(tc
->regmap
)) {
1318 ret
= PTR_ERR(tc
->regmap
);
1319 dev_err(dev
, "Failed to initialize regmap: %d\n", ret
);
1323 ret
= regmap_read(tc
->regmap
, TC_IDREG
, &tc
->rev
);
1325 dev_err(tc
->dev
, "can not read device ID: %d\n", ret
);
1329 if ((tc
->rev
!= 0x6601) && (tc
->rev
!= 0x6603)) {
1330 dev_err(tc
->dev
, "invalid device ID: 0x%08x\n", tc
->rev
);
1334 tc
->assr
= (tc
->rev
== 0x6601); /* Enable ASSR for eDP panels */
1336 ret
= tc_aux_link_setup(tc
);
1340 /* Register DP AUX channel */
1341 tc
->aux
.name
= "TC358767 AUX i2c adapter";
1342 tc
->aux
.dev
= tc
->dev
;
1343 tc
->aux
.transfer
= tc_aux_transfer
;
1344 ret
= drm_dp_aux_register(&tc
->aux
);
1348 ret
= tc_get_display_props(tc
);
1350 goto err_unregister_aux
;
1352 tc_connector_set_polling(tc
, &tc
->connector
);
1354 tc
->bridge
.funcs
= &tc_bridge_funcs
;
1355 tc
->bridge
.of_node
= dev
->of_node
;
1356 drm_bridge_add(&tc
->bridge
);
1358 i2c_set_clientdata(client
, tc
);
1362 drm_dp_aux_unregister(&tc
->aux
);
1366 static int tc_remove(struct i2c_client
*client
)
1368 struct tc_data
*tc
= i2c_get_clientdata(client
);
1370 drm_bridge_remove(&tc
->bridge
);
1371 drm_dp_aux_unregister(&tc
->aux
);
1378 static const struct i2c_device_id tc358767_i2c_ids
[] = {
1382 MODULE_DEVICE_TABLE(i2c
, tc358767_i2c_ids
);
1384 static const struct of_device_id tc358767_of_ids
[] = {
1385 { .compatible
= "toshiba,tc358767", },
1388 MODULE_DEVICE_TABLE(of
, tc358767_of_ids
);
1390 static struct i2c_driver tc358767_driver
= {
1393 .of_match_table
= tc358767_of_ids
,
1395 .id_table
= tc358767_i2c_ids
,
1397 .remove
= tc_remove
,
1399 module_i2c_driver(tc358767_driver
);
1401 MODULE_AUTHOR("Andrey Gusakov <andrey.gusakov@cogentembedded.com>");
1402 MODULE_DESCRIPTION("tc358767 eDP encoder driver");
1403 MODULE_LICENSE("GPL");