1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2017 Rockchip Electronics Co. Ltd.
5 * Author: Zheng Yang <zhengyang@rock-chips.com>
6 * Heiko Stuebner <heiko@sntech.de>
10 #include <linux/clk-provider.h>
11 #include <linux/delay.h>
13 #include <linux/interrupt.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/nvmem-consumer.h>
18 #include <linux/of_device.h>
19 #include <linux/platform_device.h>
20 #include <linux/regmap.h>
21 #include <linux/phy/phy.h>
22 #include <linux/slab.h>
24 #define UPDATE(x, h, l) (((x) << (l)) & GENMASK((h), (l)))
27 #define RK3228_PRE_PLL_REFCLK_SEL_PCLK BIT(0)
29 #define RK3228_BYPASS_RXSENSE_EN BIT(2)
30 #define RK3228_BYPASS_PWRON_EN BIT(1)
31 #define RK3228_BYPASS_PLLPD_EN BIT(0)
33 #define RK3228_BYPASS_PDATA_EN BIT(4)
34 #define RK3228_PDATAEN_DISABLE BIT(0)
36 #define RK3228_BYPASS_AUTO_TERM_RES_CAL BIT(7)
37 #define RK3228_AUTO_TERM_RES_CAL_SPEED_14_8(x) UPDATE(x, 6, 0)
39 #define RK3228_AUTO_TERM_RES_CAL_SPEED_7_0(x) UPDATE(x, 7, 0)
41 #define RK3228_POST_PLL_CTRL_MANUAL BIT(0)
43 #define RK3228_POST_PLL_POWER_DOWN BIT(5)
44 #define RK3228_PRE_PLL_POWER_DOWN BIT(4)
45 #define RK3228_RXSENSE_CLK_CH_ENABLE BIT(3)
46 #define RK3228_RXSENSE_DATA_CH2_ENABLE BIT(2)
47 #define RK3228_RXSENSE_DATA_CH1_ENABLE BIT(1)
48 #define RK3228_RXSENSE_DATA_CH0_ENABLE BIT(0)
50 #define RK3228_BANDGAP_ENABLE BIT(4)
51 #define RK3228_TMDS_DRIVER_ENABLE GENMASK(3, 0)
53 #define RK3228_PRE_PLL_FB_DIV_8_MASK BIT(7)
54 #define RK3228_PRE_PLL_FB_DIV_8(x) UPDATE((x) >> 8, 7, 7)
55 #define RK3228_PCLK_VCO_DIV_5_MASK BIT(5)
56 #define RK3228_PCLK_VCO_DIV_5(x) UPDATE(x, 5, 5)
57 #define RK3228_PRE_PLL_PRE_DIV_MASK GENMASK(4, 0)
58 #define RK3228_PRE_PLL_PRE_DIV(x) UPDATE(x, 4, 0)
60 #define RK3228_PRE_PLL_FB_DIV_7_0(x) UPDATE(x, 7, 0)
62 #define RK3228_PRE_PLL_PCLK_DIV_B_MASK GENMASK(6, 5)
63 #define RK3228_PRE_PLL_PCLK_DIV_B_SHIFT 5
64 #define RK3228_PRE_PLL_PCLK_DIV_B(x) UPDATE(x, 6, 5)
65 #define RK3228_PRE_PLL_PCLK_DIV_A_MASK GENMASK(4, 0)
66 #define RK3228_PRE_PLL_PCLK_DIV_A(x) UPDATE(x, 4, 0)
68 #define RK3228_PRE_PLL_PCLK_DIV_C_MASK GENMASK(6, 5)
69 #define RK3228_PRE_PLL_PCLK_DIV_C(x) UPDATE(x, 6, 5)
70 #define RK3228_PRE_PLL_PCLK_DIV_D_MASK GENMASK(4, 0)
71 #define RK3228_PRE_PLL_PCLK_DIV_D(x) UPDATE(x, 4, 0)
73 #define RK3228_PRE_PLL_TMDSCLK_DIV_C_MASK GENMASK(5, 4)
74 #define RK3228_PRE_PLL_TMDSCLK_DIV_C(x) UPDATE(x, 5, 4)
75 #define RK3228_PRE_PLL_TMDSCLK_DIV_A_MASK GENMASK(3, 2)
76 #define RK3228_PRE_PLL_TMDSCLK_DIV_A(x) UPDATE(x, 3, 2)
77 #define RK3228_PRE_PLL_TMDSCLK_DIV_B_MASK GENMASK(1, 0)
78 #define RK3228_PRE_PLL_TMDSCLK_DIV_B(x) UPDATE(x, 1, 0)
80 #define RK3228_PRE_PLL_LOCK_STATUS BIT(0)
82 #define RK3228_POST_PLL_POST_DIV_ENABLE UPDATE(3, 7, 6)
83 #define RK3228_POST_PLL_PRE_DIV_MASK GENMASK(4, 0)
84 #define RK3228_POST_PLL_PRE_DIV(x) UPDATE(x, 4, 0)
86 #define RK3228_POST_PLL_FB_DIV_7_0(x) UPDATE(x, 7, 0)
88 #define RK3228_POST_PLL_FB_DIV_8_MASK BIT(7)
89 #define RK3228_POST_PLL_FB_DIV_8(x) UPDATE((x) >> 8, 7, 7)
90 #define RK3228_POST_PLL_POST_DIV_MASK GENMASK(5, 4)
91 #define RK3228_POST_PLL_POST_DIV(x) UPDATE(x, 5, 4)
92 #define RK3228_POST_PLL_LOCK_STATUS BIT(0)
94 #define RK3228_TMDS_CH_TA_ENABLE GENMASK(7, 4)
96 #define RK3228_TMDS_CLK_CH_TA(x) UPDATE(x, 7, 6)
97 #define RK3228_TMDS_DATA_CH2_TA(x) UPDATE(x, 5, 4)
98 #define RK3228_TMDS_DATA_CH1_TA(x) UPDATE(x, 3, 2)
99 #define RK3228_TMDS_DATA_CH0_TA(x) UPDATE(x, 1, 0)
101 #define RK3228_TMDS_DATA_CH2_PRE_EMPHASIS_MASK GENMASK(5, 4)
102 #define RK3228_TMDS_DATA_CH2_PRE_EMPHASIS(x) UPDATE(x, 5, 4)
103 #define RK3228_TMDS_DATA_CH1_PRE_EMPHASIS_MASK GENMASK(3, 2)
104 #define RK3228_TMDS_DATA_CH1_PRE_EMPHASIS(x) UPDATE(x, 3, 2)
105 #define RK3228_TMDS_DATA_CH0_PRE_EMPHASIS_MASK GENMASK(1, 0)
106 #define RK3228_TMDS_DATA_CH0_PRE_EMPHASIS(x) UPDATE(x, 1, 0)
108 #define RK3228_TMDS_CLK_CH_OUTPUT_SWING(x) UPDATE(x, 7, 4)
109 #define RK3228_TMDS_DATA_CH2_OUTPUT_SWING(x) UPDATE(x, 3, 0)
111 #define RK3228_TMDS_DATA_CH1_OUTPUT_SWING(x) UPDATE(x, 7, 4)
112 #define RK3228_TMDS_DATA_CH0_OUTPUT_SWING(x) UPDATE(x, 3, 0)
115 #define RK3328_BYPASS_RXSENSE_EN BIT(2)
116 #define RK3328_BYPASS_POWERON_EN BIT(1)
117 #define RK3328_BYPASS_PLLPD_EN BIT(0)
119 #define RK3328_INT_POL_HIGH BIT(7)
120 #define RK3328_BYPASS_PDATA_EN BIT(4)
121 #define RK3328_PDATA_EN BIT(0)
123 #define RK3328_INT_TMDS_CLK(x) UPDATE(x, 7, 4)
124 #define RK3328_INT_TMDS_D2(x) UPDATE(x, 3, 0)
126 #define RK3328_INT_TMDS_D1(x) UPDATE(x, 7, 4)
127 #define RK3328_INT_TMDS_D0(x) UPDATE(x, 3, 0)
128 /* for all RK3328_INT_TMDS_*, ESD_DET as defined in 0xc8-0xcb */
129 #define RK3328_INT_AGND_LOW_PULSE_LOCKED BIT(3)
130 #define RK3328_INT_RXSENSE_LOW_PULSE_LOCKED BIT(2)
131 #define RK3328_INT_VSS_AGND_ESD_DET BIT(1)
132 #define RK3328_INT_AGND_VSS_ESD_DET BIT(0)
134 #define RK3328_PCLK_VCO_DIV_5_MASK BIT(1)
135 #define RK3328_PCLK_VCO_DIV_5(x) UPDATE(x, 1, 1)
136 #define RK3328_PRE_PLL_POWER_DOWN BIT(0)
138 #define RK3328_PRE_PLL_PRE_DIV_MASK GENMASK(5, 0)
139 #define RK3328_PRE_PLL_PRE_DIV(x) UPDATE(x, 5, 0)
141 /* unset means center spread */
142 #define RK3328_SPREAD_SPECTRUM_MOD_DOWN BIT(7)
143 #define RK3328_SPREAD_SPECTRUM_MOD_DISABLE BIT(6)
144 #define RK3328_PRE_PLL_FRAC_DIV_DISABLE UPDATE(3, 5, 4)
145 #define RK3328_PRE_PLL_FB_DIV_11_8_MASK GENMASK(3, 0)
146 #define RK3328_PRE_PLL_FB_DIV_11_8(x) UPDATE((x) >> 8, 3, 0)
148 #define RK3328_PRE_PLL_FB_DIV_7_0(x) UPDATE(x, 7, 0)
150 #define RK3328_PRE_PLL_TMDSCLK_DIV_C_MASK GENMASK(1, 0)
151 #define RK3328_PRE_PLL_TMDSCLK_DIV_C(x) UPDATE(x, 1, 0)
152 #define RK3328_PRE_PLL_TMDSCLK_DIV_B_MASK GENMASK(3, 2)
153 #define RK3328_PRE_PLL_TMDSCLK_DIV_B(x) UPDATE(x, 3, 2)
154 #define RK3328_PRE_PLL_TMDSCLK_DIV_A_MASK GENMASK(5, 4)
155 #define RK3328_PRE_PLL_TMDSCLK_DIV_A(x) UPDATE(x, 5, 4)
157 #define RK3328_PRE_PLL_PCLK_DIV_B_SHIFT 5
158 #define RK3328_PRE_PLL_PCLK_DIV_B_MASK GENMASK(6, 5)
159 #define RK3328_PRE_PLL_PCLK_DIV_B(x) UPDATE(x, 6, 5)
160 #define RK3328_PRE_PLL_PCLK_DIV_A_MASK GENMASK(4, 0)
161 #define RK3328_PRE_PLL_PCLK_DIV_A(x) UPDATE(x, 4, 0)
163 #define RK3328_PRE_PLL_PCLK_DIV_C_SHIFT 5
164 #define RK3328_PRE_PLL_PCLK_DIV_C_MASK GENMASK(6, 5)
165 #define RK3328_PRE_PLL_PCLK_DIV_C(x) UPDATE(x, 6, 5)
166 #define RK3328_PRE_PLL_PCLK_DIV_D_MASK GENMASK(4, 0)
167 #define RK3328_PRE_PLL_PCLK_DIV_D(x) UPDATE(x, 4, 0)
169 #define RK3328_PRE_PLL_LOCK_STATUS BIT(0)
171 #define RK3328_POST_PLL_POST_DIV_ENABLE GENMASK(3, 2)
172 #define RK3328_POST_PLL_REFCLK_SEL_TMDS BIT(1)
173 #define RK3328_POST_PLL_POWER_DOWN BIT(0)
175 #define RK3328_POST_PLL_FB_DIV_8(x) UPDATE((x) >> 8, 7, 7)
176 #define RK3328_POST_PLL_PRE_DIV(x) UPDATE(x, 4, 0)
178 #define RK3328_POST_PLL_FB_DIV_7_0(x) UPDATE(x, 7, 0)
180 #define RK3328_POST_PLL_POST_DIV_MASK GENMASK(1, 0)
181 #define RK3328_POST_PLL_POST_DIV_2 0x0
182 #define RK3328_POST_PLL_POST_DIV_4 0x1
183 #define RK3328_POST_PLL_POST_DIV_8 0x3
185 #define RK3328_POST_PLL_LOCK_STATUS BIT(0)
187 #define RK3328_BANDGAP_ENABLE BIT(2)
189 #define RK3328_TMDS_CLK_DRIVER_EN BIT(3)
190 #define RK3328_TMDS_D2_DRIVER_EN BIT(2)
191 #define RK3328_TMDS_D1_DRIVER_EN BIT(1)
192 #define RK3328_TMDS_D0_DRIVER_EN BIT(0)
193 #define RK3328_TMDS_DRIVER_ENABLE (RK3328_TMDS_CLK_DRIVER_EN | \
194 RK3328_TMDS_D2_DRIVER_EN | \
195 RK3328_TMDS_D1_DRIVER_EN | \
196 RK3328_TMDS_D0_DRIVER_EN)
198 #define RK3328_BYPASS_TERM_RESISTOR_CALIB BIT(7)
199 #define RK3328_TERM_RESISTOR_CALIB_SPEED_14_8(x) UPDATE((x) >> 8, 6, 0)
201 #define RK3328_TERM_RESISTOR_CALIB_SPEED_7_0(x) UPDATE(x, 7, 9)
203 #define RK3328_TERM_RESISTOR_50 UPDATE(0, 2, 1)
204 #define RK3328_TERM_RESISTOR_62_5 UPDATE(1, 2, 1)
205 #define RK3328_TERM_RESISTOR_75 UPDATE(2, 2, 1)
206 #define RK3328_TERM_RESISTOR_100 UPDATE(3, 2, 1)
207 /* REG 0xc8 - 0xcb */
208 #define RK3328_ESD_DETECT_MASK GENMASK(7, 6)
209 #define RK3328_ESD_DETECT_340MV (0x0 << 6)
210 #define RK3328_ESD_DETECT_280MV (0x1 << 6)
211 #define RK3328_ESD_DETECT_260MV (0x2 << 6)
212 #define RK3328_ESD_DETECT_240MV (0x3 << 6)
213 /* resistors can be used in parallel */
214 #define RK3328_TMDS_TERM_RESIST_MASK GENMASK(5, 0)
215 #define RK3328_TMDS_TERM_RESIST_75 BIT(5)
216 #define RK3328_TMDS_TERM_RESIST_150 BIT(4)
217 #define RK3328_TMDS_TERM_RESIST_300 BIT(3)
218 #define RK3328_TMDS_TERM_RESIST_600 BIT(2)
219 #define RK3328_TMDS_TERM_RESIST_1000 BIT(1)
220 #define RK3328_TMDS_TERM_RESIST_2000 BIT(0)
222 #define RK3328_PRE_PLL_FRAC_DIV_23_16(x) UPDATE((x) >> 16, 7, 0)
224 #define RK3328_PRE_PLL_FRAC_DIV_15_8(x) UPDATE((x) >> 8, 7, 0)
226 #define RK3328_PRE_PLL_FRAC_DIV_7_0(x) UPDATE(x, 7, 0)
228 struct inno_hdmi_phy_drv_data
;
230 struct inno_hdmi_phy
{
232 struct regmap
*regmap
;
241 const struct inno_hdmi_phy_drv_data
*plat_data
;
247 unsigned long pixclock
;
250 struct pre_pll_config
{
251 unsigned long pixclock
;
252 unsigned long tmdsclock
;
266 struct post_pll_config
{
267 unsigned long tmdsclock
;
275 unsigned long tmdsclock
;
279 struct inno_hdmi_phy_ops
{
280 int (*init
)(struct inno_hdmi_phy
*inno
);
281 int (*power_on
)(struct inno_hdmi_phy
*inno
,
282 const struct post_pll_config
*cfg
,
283 const struct phy_config
*phy_cfg
);
284 void (*power_off
)(struct inno_hdmi_phy
*inno
);
287 struct inno_hdmi_phy_drv_data
{
288 const struct inno_hdmi_phy_ops
*ops
;
289 const struct clk_ops
*clk_ops
;
290 const struct phy_config
*phy_cfg_table
;
293 static const struct pre_pll_config pre_pll_cfg_table
[] = {
294 { 27000000, 27000000, 1, 90, 3, 2, 2, 10, 3, 3, 4, 0, 0},
295 { 27000000, 33750000, 1, 90, 1, 3, 3, 10, 3, 3, 4, 0, 0},
296 { 40000000, 40000000, 1, 80, 2, 2, 2, 12, 2, 2, 2, 0, 0},
297 { 59341000, 59341000, 1, 98, 3, 1, 2, 1, 3, 3, 4, 0, 0xE6AE6B},
298 { 59400000, 59400000, 1, 99, 3, 1, 1, 1, 3, 3, 4, 0, 0},
299 { 59341000, 74176250, 1, 98, 0, 3, 3, 1, 3, 3, 4, 0, 0xE6AE6B},
300 { 59400000, 74250000, 1, 99, 1, 2, 2, 1, 3, 3, 4, 0, 0},
301 { 74176000, 74176000, 1, 98, 1, 2, 2, 1, 2, 3, 4, 0, 0xE6AE6B},
302 { 74250000, 74250000, 1, 99, 1, 2, 2, 1, 2, 3, 4, 0, 0},
303 { 74176000, 92720000, 4, 494, 1, 2, 2, 1, 3, 3, 4, 0, 0x816817},
304 { 74250000, 92812500, 4, 495, 1, 2, 2, 1, 3, 3, 4, 0, 0},
305 {148352000, 148352000, 1, 98, 1, 1, 1, 1, 2, 2, 2, 0, 0xE6AE6B},
306 {148500000, 148500000, 1, 99, 1, 1, 1, 1, 2, 2, 2, 0, 0},
307 {148352000, 185440000, 4, 494, 0, 2, 2, 1, 3, 2, 2, 0, 0x816817},
308 {148500000, 185625000, 4, 495, 0, 2, 2, 1, 3, 2, 2, 0, 0},
309 {296703000, 296703000, 1, 98, 0, 1, 1, 1, 0, 2, 2, 0, 0xE6AE6B},
310 {297000000, 297000000, 1, 99, 0, 1, 1, 1, 0, 2, 2, 0, 0},
311 {296703000, 370878750, 4, 494, 1, 2, 0, 1, 3, 1, 1, 0, 0x816817},
312 {297000000, 371250000, 4, 495, 1, 2, 0, 1, 3, 1, 1, 0, 0},
313 {593407000, 296703500, 1, 98, 0, 1, 1, 1, 0, 2, 1, 0, 0xE6AE6B},
314 {594000000, 297000000, 1, 99, 0, 1, 1, 1, 0, 2, 1, 0, 0},
315 {593407000, 370879375, 4, 494, 1, 2, 0, 1, 3, 1, 1, 1, 0x816817},
316 {594000000, 371250000, 4, 495, 1, 2, 0, 1, 3, 1, 1, 1, 0},
317 {593407000, 593407000, 1, 98, 0, 2, 0, 1, 0, 1, 1, 0, 0xE6AE6B},
318 {594000000, 594000000, 1, 99, 0, 2, 0, 1, 0, 1, 1, 0, 0},
322 static const struct post_pll_config post_pll_cfg_table
[] = {
323 {33750000, 1, 40, 8, 1},
324 {33750000, 1, 80, 8, 2},
325 {74250000, 1, 40, 8, 1},
326 {74250000, 18, 80, 8, 2},
327 {148500000, 2, 40, 4, 3},
328 {297000000, 4, 40, 2, 3},
329 {594000000, 8, 40, 1, 3},
333 /* phy tuning values for an undocumented set of registers */
334 static const struct phy_config rk3228_phy_cfg
[] = {
336 0xaa, 0x00, 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00,
337 0x00, 0x00, 0x00, 0x00, 0x00,
341 0xaa, 0x15, 0x6a, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x00, 0x00, 0x00, 0x00,
346 0xaa, 0x15, 0x7a, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x00, 0x00, 0x00, 0x00,
349 }, { /* sentinel */ },
352 /* phy tuning values for an undocumented set of registers */
353 static const struct phy_config rk3328_phy_cfg
[] = {
355 0x07, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x08, 0x08, 0x08,
356 0x00, 0xac, 0xcc, 0xcc, 0xcc,
360 0x0b, 0x0d, 0x0d, 0x0d, 0x07, 0x15, 0x08, 0x08, 0x08,
361 0x3f, 0xac, 0xcc, 0xcd, 0xdd,
365 0x10, 0x1a, 0x1a, 0x1a, 0x07, 0x15, 0x08, 0x08, 0x08,
366 0x00, 0xac, 0xcc, 0xcc, 0xcc,
368 }, { /* sentinel */ },
371 static inline struct inno_hdmi_phy
*to_inno_hdmi_phy(struct clk_hw
*hw
)
373 return container_of(hw
, struct inno_hdmi_phy
, hw
);
377 * The register description of the IP block does not use any distinct names
378 * but instead the databook simply numbers the registers in one-increments.
379 * As the registers are obviously 32bit sized, the inno_* functions
380 * translate the databook register names to the actual registers addresses.
382 static inline void inno_write(struct inno_hdmi_phy
*inno
, u32 reg
, u8 val
)
384 regmap_write(inno
->regmap
, reg
* 4, val
);
387 static inline u8
inno_read(struct inno_hdmi_phy
*inno
, u32 reg
)
391 regmap_read(inno
->regmap
, reg
* 4, &val
);
396 static inline void inno_update_bits(struct inno_hdmi_phy
*inno
, u8 reg
,
399 regmap_update_bits(inno
->regmap
, reg
* 4, mask
, val
);
402 #define inno_poll(inno, reg, val, cond, sleep_us, timeout_us) \
403 regmap_read_poll_timeout((inno)->regmap, (reg) * 4, val, cond, \
404 sleep_us, timeout_us)
406 static unsigned long inno_hdmi_phy_get_tmdsclk(struct inno_hdmi_phy
*inno
,
409 int bus_width
= phy_get_bus_width(inno
->phy
);
418 return (u64
)rate
* bus_width
/ 8;
424 static irqreturn_t
inno_hdmi_phy_rk3328_hardirq(int irq
, void *dev_id
)
426 struct inno_hdmi_phy
*inno
= dev_id
;
427 int intr_stat1
, intr_stat2
, intr_stat3
;
429 intr_stat1
= inno_read(inno
, 0x04);
430 intr_stat2
= inno_read(inno
, 0x06);
431 intr_stat3
= inno_read(inno
, 0x08);
434 inno_write(inno
, 0x04, intr_stat1
);
436 inno_write(inno
, 0x06, intr_stat2
);
438 inno_write(inno
, 0x08, intr_stat3
);
440 if (intr_stat1
|| intr_stat2
|| intr_stat3
)
441 return IRQ_WAKE_THREAD
;
446 static irqreturn_t
inno_hdmi_phy_rk3328_irq(int irq
, void *dev_id
)
448 struct inno_hdmi_phy
*inno
= dev_id
;
450 inno_update_bits(inno
, 0x02, RK3328_PDATA_EN
, 0);
451 usleep_range(10, 20);
452 inno_update_bits(inno
, 0x02, RK3328_PDATA_EN
, RK3328_PDATA_EN
);
457 static int inno_hdmi_phy_power_on(struct phy
*phy
)
459 struct inno_hdmi_phy
*inno
= phy_get_drvdata(phy
);
460 const struct post_pll_config
*cfg
= post_pll_cfg_table
;
461 const struct phy_config
*phy_cfg
= inno
->plat_data
->phy_cfg_table
;
462 unsigned long tmdsclock
= inno_hdmi_phy_get_tmdsclk(inno
,
467 dev_err(inno
->dev
, "TMDS clock is zero!\n");
471 if (!inno
->plat_data
->ops
->power_on
)
474 for (; cfg
->tmdsclock
!= 0; cfg
++)
475 if (tmdsclock
<= cfg
->tmdsclock
&&
476 cfg
->version
& inno
->chip_version
)
479 for (; phy_cfg
->tmdsclock
!= 0; phy_cfg
++)
480 if (tmdsclock
<= phy_cfg
->tmdsclock
)
483 if (cfg
->tmdsclock
== 0 || phy_cfg
->tmdsclock
== 0)
486 dev_dbg(inno
->dev
, "Inno HDMI PHY Power On\n");
488 ret
= clk_prepare_enable(inno
->phyclk
);
492 ret
= inno
->plat_data
->ops
->power_on(inno
, cfg
, phy_cfg
);
494 clk_disable_unprepare(inno
->phyclk
);
501 static int inno_hdmi_phy_power_off(struct phy
*phy
)
503 struct inno_hdmi_phy
*inno
= phy_get_drvdata(phy
);
505 if (!inno
->plat_data
->ops
->power_off
)
508 inno
->plat_data
->ops
->power_off(inno
);
510 clk_disable_unprepare(inno
->phyclk
);
512 dev_dbg(inno
->dev
, "Inno HDMI PHY Power Off\n");
517 static const struct phy_ops inno_hdmi_phy_ops
= {
518 .owner
= THIS_MODULE
,
519 .power_on
= inno_hdmi_phy_power_on
,
520 .power_off
= inno_hdmi_phy_power_off
,
524 struct pre_pll_config
*inno_hdmi_phy_get_pre_pll_cfg(struct inno_hdmi_phy
*inno
,
527 const struct pre_pll_config
*cfg
= pre_pll_cfg_table
;
528 unsigned long tmdsclock
= inno_hdmi_phy_get_tmdsclk(inno
, rate
);
530 for (; cfg
->pixclock
!= 0; cfg
++)
531 if (cfg
->pixclock
== rate
&& cfg
->tmdsclock
== tmdsclock
)
534 if (cfg
->pixclock
== 0)
535 return ERR_PTR(-EINVAL
);
540 static int inno_hdmi_phy_rk3228_clk_is_prepared(struct clk_hw
*hw
)
542 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
545 status
= inno_read(inno
, 0xe0) & RK3228_PRE_PLL_POWER_DOWN
;
546 return status
? 0 : 1;
549 static int inno_hdmi_phy_rk3228_clk_prepare(struct clk_hw
*hw
)
551 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
553 inno_update_bits(inno
, 0xe0, RK3228_PRE_PLL_POWER_DOWN
, 0);
557 static void inno_hdmi_phy_rk3228_clk_unprepare(struct clk_hw
*hw
)
559 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
561 inno_update_bits(inno
, 0xe0, RK3228_PRE_PLL_POWER_DOWN
,
562 RK3228_PRE_PLL_POWER_DOWN
);
566 unsigned long inno_hdmi_phy_rk3228_clk_recalc_rate(struct clk_hw
*hw
,
567 unsigned long parent_rate
)
569 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
570 u8 nd
, no_a
, no_b
, no_d
;
574 nd
= inno_read(inno
, 0xe2) & RK3228_PRE_PLL_PRE_DIV_MASK
;
575 nf
= (inno_read(inno
, 0xe2) & RK3228_PRE_PLL_FB_DIV_8_MASK
) << 1;
576 nf
|= inno_read(inno
, 0xe3);
577 vco
= parent_rate
* nf
;
579 if (inno_read(inno
, 0xe2) & RK3228_PCLK_VCO_DIV_5_MASK
) {
582 no_a
= inno_read(inno
, 0xe4) & RK3228_PRE_PLL_PCLK_DIV_A_MASK
;
585 no_b
= inno_read(inno
, 0xe4) & RK3228_PRE_PLL_PCLK_DIV_B_MASK
;
586 no_b
>>= RK3228_PRE_PLL_PCLK_DIV_B_SHIFT
;
588 no_d
= inno_read(inno
, 0xe5) & RK3228_PRE_PLL_PCLK_DIV_D_MASK
;
590 do_div(vco
, (nd
* (no_a
== 1 ? no_b
: no_a
) * no_d
* 2));
593 inno
->pixclock
= vco
;
595 dev_dbg(inno
->dev
, "%s rate %lu\n", __func__
, inno
->pixclock
);
600 static long inno_hdmi_phy_rk3228_clk_round_rate(struct clk_hw
*hw
,
602 unsigned long *parent_rate
)
604 const struct pre_pll_config
*cfg
= pre_pll_cfg_table
;
606 for (; cfg
->pixclock
!= 0; cfg
++)
607 if (cfg
->pixclock
== rate
&& !cfg
->fracdiv
)
610 if (cfg
->pixclock
== 0)
613 return cfg
->pixclock
;
616 static int inno_hdmi_phy_rk3228_clk_set_rate(struct clk_hw
*hw
,
618 unsigned long parent_rate
)
620 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
621 const struct pre_pll_config
*cfg
= pre_pll_cfg_table
;
622 unsigned long tmdsclock
= inno_hdmi_phy_get_tmdsclk(inno
, rate
);
626 dev_dbg(inno
->dev
, "%s rate %lu tmdsclk %lu\n",
627 __func__
, rate
, tmdsclock
);
629 cfg
= inno_hdmi_phy_get_pre_pll_cfg(inno
, rate
);
633 /* Power down PRE-PLL */
634 inno_update_bits(inno
, 0xe0, RK3228_PRE_PLL_POWER_DOWN
,
635 RK3228_PRE_PLL_POWER_DOWN
);
637 inno_update_bits(inno
, 0xe2, RK3228_PRE_PLL_FB_DIV_8_MASK
|
638 RK3228_PCLK_VCO_DIV_5_MASK
|
639 RK3228_PRE_PLL_PRE_DIV_MASK
,
640 RK3228_PRE_PLL_FB_DIV_8(cfg
->fbdiv
) |
641 RK3228_PCLK_VCO_DIV_5(cfg
->vco_div_5_en
) |
642 RK3228_PRE_PLL_PRE_DIV(cfg
->prediv
));
643 inno_write(inno
, 0xe3, RK3228_PRE_PLL_FB_DIV_7_0(cfg
->fbdiv
));
644 inno_update_bits(inno
, 0xe4, RK3228_PRE_PLL_PCLK_DIV_B_MASK
|
645 RK3228_PRE_PLL_PCLK_DIV_A_MASK
,
646 RK3228_PRE_PLL_PCLK_DIV_B(cfg
->pclk_div_b
) |
647 RK3228_PRE_PLL_PCLK_DIV_A(cfg
->pclk_div_a
));
648 inno_update_bits(inno
, 0xe5, RK3228_PRE_PLL_PCLK_DIV_C_MASK
|
649 RK3228_PRE_PLL_PCLK_DIV_D_MASK
,
650 RK3228_PRE_PLL_PCLK_DIV_C(cfg
->pclk_div_c
) |
651 RK3228_PRE_PLL_PCLK_DIV_D(cfg
->pclk_div_d
));
652 inno_update_bits(inno
, 0xe6, RK3228_PRE_PLL_TMDSCLK_DIV_C_MASK
|
653 RK3228_PRE_PLL_TMDSCLK_DIV_A_MASK
|
654 RK3228_PRE_PLL_TMDSCLK_DIV_B_MASK
,
655 RK3228_PRE_PLL_TMDSCLK_DIV_C(cfg
->tmds_div_c
) |
656 RK3228_PRE_PLL_TMDSCLK_DIV_A(cfg
->tmds_div_a
) |
657 RK3228_PRE_PLL_TMDSCLK_DIV_B(cfg
->tmds_div_b
));
659 /* Power up PRE-PLL */
660 inno_update_bits(inno
, 0xe0, RK3228_PRE_PLL_POWER_DOWN
, 0);
662 /* Wait for Pre-PLL lock */
663 ret
= inno_poll(inno
, 0xe8, v
, v
& RK3228_PRE_PLL_LOCK_STATUS
,
666 dev_err(inno
->dev
, "Pre-PLL locking failed\n");
670 inno
->pixclock
= rate
;
675 static const struct clk_ops inno_hdmi_phy_rk3228_clk_ops
= {
676 .prepare
= inno_hdmi_phy_rk3228_clk_prepare
,
677 .unprepare
= inno_hdmi_phy_rk3228_clk_unprepare
,
678 .is_prepared
= inno_hdmi_phy_rk3228_clk_is_prepared
,
679 .recalc_rate
= inno_hdmi_phy_rk3228_clk_recalc_rate
,
680 .round_rate
= inno_hdmi_phy_rk3228_clk_round_rate
,
681 .set_rate
= inno_hdmi_phy_rk3228_clk_set_rate
,
684 static int inno_hdmi_phy_rk3328_clk_is_prepared(struct clk_hw
*hw
)
686 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
689 status
= inno_read(inno
, 0xa0) & RK3328_PRE_PLL_POWER_DOWN
;
690 return status
? 0 : 1;
693 static int inno_hdmi_phy_rk3328_clk_prepare(struct clk_hw
*hw
)
695 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
697 inno_update_bits(inno
, 0xa0, RK3328_PRE_PLL_POWER_DOWN
, 0);
701 static void inno_hdmi_phy_rk3328_clk_unprepare(struct clk_hw
*hw
)
703 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
705 inno_update_bits(inno
, 0xa0, RK3328_PRE_PLL_POWER_DOWN
,
706 RK3328_PRE_PLL_POWER_DOWN
);
710 unsigned long inno_hdmi_phy_rk3328_clk_recalc_rate(struct clk_hw
*hw
,
711 unsigned long parent_rate
)
713 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
715 u8 nd
, no_a
, no_b
, no_c
, no_d
;
719 nd
= inno_read(inno
, 0xa1) & RK3328_PRE_PLL_PRE_DIV_MASK
;
720 nf
= ((inno_read(inno
, 0xa2) & RK3328_PRE_PLL_FB_DIV_11_8_MASK
) << 8);
721 nf
|= inno_read(inno
, 0xa3);
722 vco
= parent_rate
* nf
;
724 if (!(inno_read(inno
, 0xa2) & RK3328_PRE_PLL_FRAC_DIV_DISABLE
)) {
725 frac
= inno_read(inno
, 0xd3) |
726 (inno_read(inno
, 0xd2) << 8) |
727 (inno_read(inno
, 0xd1) << 16);
728 vco
+= DIV_ROUND_CLOSEST(parent_rate
* frac
, (1 << 24));
731 if (inno_read(inno
, 0xa0) & RK3328_PCLK_VCO_DIV_5_MASK
) {
734 no_a
= inno_read(inno
, 0xa5) & RK3328_PRE_PLL_PCLK_DIV_A_MASK
;
735 no_b
= inno_read(inno
, 0xa5) & RK3328_PRE_PLL_PCLK_DIV_B_MASK
;
736 no_b
>>= RK3328_PRE_PLL_PCLK_DIV_B_SHIFT
;
738 no_c
= inno_read(inno
, 0xa6) & RK3328_PRE_PLL_PCLK_DIV_C_MASK
;
739 no_c
>>= RK3328_PRE_PLL_PCLK_DIV_C_SHIFT
;
741 no_d
= inno_read(inno
, 0xa6) & RK3328_PRE_PLL_PCLK_DIV_D_MASK
;
743 do_div(vco
, (nd
* (no_a
== 1 ? no_b
: no_a
) * no_d
* 2));
746 inno
->pixclock
= vco
;
747 dev_dbg(inno
->dev
, "%s rate %lu\n", __func__
, inno
->pixclock
);
752 static long inno_hdmi_phy_rk3328_clk_round_rate(struct clk_hw
*hw
,
754 unsigned long *parent_rate
)
756 const struct pre_pll_config
*cfg
= pre_pll_cfg_table
;
758 for (; cfg
->pixclock
!= 0; cfg
++)
759 if (cfg
->pixclock
== rate
)
762 if (cfg
->pixclock
== 0)
765 return cfg
->pixclock
;
768 static int inno_hdmi_phy_rk3328_clk_set_rate(struct clk_hw
*hw
,
770 unsigned long parent_rate
)
772 struct inno_hdmi_phy
*inno
= to_inno_hdmi_phy(hw
);
773 const struct pre_pll_config
*cfg
= pre_pll_cfg_table
;
774 unsigned long tmdsclock
= inno_hdmi_phy_get_tmdsclk(inno
, rate
);
778 dev_dbg(inno
->dev
, "%s rate %lu tmdsclk %lu\n",
779 __func__
, rate
, tmdsclock
);
781 cfg
= inno_hdmi_phy_get_pre_pll_cfg(inno
, rate
);
785 inno_update_bits(inno
, 0xa0, RK3328_PRE_PLL_POWER_DOWN
,
786 RK3328_PRE_PLL_POWER_DOWN
);
788 /* Configure pre-pll */
789 inno_update_bits(inno
, 0xa0, RK3228_PCLK_VCO_DIV_5_MASK
,
790 RK3228_PCLK_VCO_DIV_5(cfg
->vco_div_5_en
));
791 inno_write(inno
, 0xa1, RK3328_PRE_PLL_PRE_DIV(cfg
->prediv
));
793 val
= RK3328_SPREAD_SPECTRUM_MOD_DISABLE
;
795 val
|= RK3328_PRE_PLL_FRAC_DIV_DISABLE
;
796 inno_write(inno
, 0xa2, RK3328_PRE_PLL_FB_DIV_11_8(cfg
->fbdiv
) | val
);
797 inno_write(inno
, 0xa3, RK3328_PRE_PLL_FB_DIV_7_0(cfg
->fbdiv
));
798 inno_write(inno
, 0xa5, RK3328_PRE_PLL_PCLK_DIV_A(cfg
->pclk_div_a
) |
799 RK3328_PRE_PLL_PCLK_DIV_B(cfg
->pclk_div_b
));
800 inno_write(inno
, 0xa6, RK3328_PRE_PLL_PCLK_DIV_C(cfg
->pclk_div_c
) |
801 RK3328_PRE_PLL_PCLK_DIV_D(cfg
->pclk_div_d
));
802 inno_write(inno
, 0xa4, RK3328_PRE_PLL_TMDSCLK_DIV_C(cfg
->tmds_div_c
) |
803 RK3328_PRE_PLL_TMDSCLK_DIV_A(cfg
->tmds_div_a
) |
804 RK3328_PRE_PLL_TMDSCLK_DIV_B(cfg
->tmds_div_b
));
805 inno_write(inno
, 0xd3, RK3328_PRE_PLL_FRAC_DIV_7_0(cfg
->fracdiv
));
806 inno_write(inno
, 0xd2, RK3328_PRE_PLL_FRAC_DIV_15_8(cfg
->fracdiv
));
807 inno_write(inno
, 0xd1, RK3328_PRE_PLL_FRAC_DIV_23_16(cfg
->fracdiv
));
809 inno_update_bits(inno
, 0xa0, RK3328_PRE_PLL_POWER_DOWN
, 0);
811 /* Wait for Pre-PLL lock */
812 ret
= inno_poll(inno
, 0xa9, val
, val
& RK3328_PRE_PLL_LOCK_STATUS
,
815 dev_err(inno
->dev
, "Pre-PLL locking failed\n");
819 inno
->pixclock
= rate
;
824 static const struct clk_ops inno_hdmi_phy_rk3328_clk_ops
= {
825 .prepare
= inno_hdmi_phy_rk3328_clk_prepare
,
826 .unprepare
= inno_hdmi_phy_rk3328_clk_unprepare
,
827 .is_prepared
= inno_hdmi_phy_rk3328_clk_is_prepared
,
828 .recalc_rate
= inno_hdmi_phy_rk3328_clk_recalc_rate
,
829 .round_rate
= inno_hdmi_phy_rk3328_clk_round_rate
,
830 .set_rate
= inno_hdmi_phy_rk3328_clk_set_rate
,
833 static int inno_hdmi_phy_clk_register(struct inno_hdmi_phy
*inno
)
835 struct device
*dev
= inno
->dev
;
836 struct device_node
*np
= dev
->of_node
;
837 struct clk_init_data init
;
838 const char *parent_name
;
841 parent_name
= __clk_get_name(inno
->refoclk
);
843 init
.parent_names
= &parent_name
;
844 init
.num_parents
= 1;
846 init
.name
= "pin_hd20_pclk";
847 init
.ops
= inno
->plat_data
->clk_ops
;
849 /* optional override of the clock name */
850 of_property_read_string(np
, "clock-output-names", &init
.name
);
852 inno
->hw
.init
= &init
;
854 inno
->phyclk
= devm_clk_register(dev
, &inno
->hw
);
855 if (IS_ERR(inno
->phyclk
)) {
856 ret
= PTR_ERR(inno
->phyclk
);
857 dev_err(dev
, "failed to register clock: %d\n", ret
);
861 ret
= of_clk_add_provider(np
, of_clk_src_simple_get
, inno
->phyclk
);
863 dev_err(dev
, "failed to register clock provider: %d\n", ret
);
870 static int inno_hdmi_phy_rk3228_init(struct inno_hdmi_phy
*inno
)
873 * Use phy internal register control
874 * rxsense/poweron/pllpd/pdataen signal.
876 inno_write(inno
, 0x01, RK3228_BYPASS_RXSENSE_EN
|
877 RK3228_BYPASS_PWRON_EN
|
878 RK3228_BYPASS_PLLPD_EN
);
879 inno_update_bits(inno
, 0x02, RK3228_BYPASS_PDATA_EN
,
880 RK3228_BYPASS_PDATA_EN
);
882 /* manual power down post-PLL */
883 inno_update_bits(inno
, 0xaa, RK3228_POST_PLL_CTRL_MANUAL
,
884 RK3228_POST_PLL_CTRL_MANUAL
);
886 inno
->chip_version
= 1;
892 inno_hdmi_phy_rk3228_power_on(struct inno_hdmi_phy
*inno
,
893 const struct post_pll_config
*cfg
,
894 const struct phy_config
*phy_cfg
)
899 inno_update_bits(inno
, 0x02, RK3228_PDATAEN_DISABLE
,
900 RK3228_PDATAEN_DISABLE
);
901 inno_update_bits(inno
, 0xe0, RK3228_PRE_PLL_POWER_DOWN
|
902 RK3228_POST_PLL_POWER_DOWN
,
903 RK3228_PRE_PLL_POWER_DOWN
|
904 RK3228_POST_PLL_POWER_DOWN
);
906 /* Post-PLL update */
907 inno_update_bits(inno
, 0xe9, RK3228_POST_PLL_PRE_DIV_MASK
,
908 RK3228_POST_PLL_PRE_DIV(cfg
->prediv
));
909 inno_update_bits(inno
, 0xeb, RK3228_POST_PLL_FB_DIV_8_MASK
,
910 RK3228_POST_PLL_FB_DIV_8(cfg
->fbdiv
));
911 inno_write(inno
, 0xea, RK3228_POST_PLL_FB_DIV_7_0(cfg
->fbdiv
));
913 if (cfg
->postdiv
== 1) {
914 inno_update_bits(inno
, 0xe9, RK3228_POST_PLL_POST_DIV_ENABLE
,
917 int div
= cfg
->postdiv
/ 2 - 1;
919 inno_update_bits(inno
, 0xe9, RK3228_POST_PLL_POST_DIV_ENABLE
,
920 RK3228_POST_PLL_POST_DIV_ENABLE
);
921 inno_update_bits(inno
, 0xeb, RK3228_POST_PLL_POST_DIV_MASK
,
922 RK3228_POST_PLL_POST_DIV(div
));
925 for (v
= 0; v
< 4; v
++)
926 inno_write(inno
, 0xef + v
, phy_cfg
->regs
[v
]);
928 inno_update_bits(inno
, 0xe0, RK3228_PRE_PLL_POWER_DOWN
|
929 RK3228_POST_PLL_POWER_DOWN
, 0);
930 inno_update_bits(inno
, 0xe1, RK3228_BANDGAP_ENABLE
,
931 RK3228_BANDGAP_ENABLE
);
932 inno_update_bits(inno
, 0xe1, RK3228_TMDS_DRIVER_ENABLE
,
933 RK3228_TMDS_DRIVER_ENABLE
);
935 /* Wait for post PLL lock */
936 ret
= inno_poll(inno
, 0xeb, v
, v
& RK3228_POST_PLL_LOCK_STATUS
,
939 dev_err(inno
->dev
, "Post-PLL locking failed\n");
943 if (cfg
->tmdsclock
> 340000000)
946 inno_update_bits(inno
, 0x02, RK3228_PDATAEN_DISABLE
, 0);
950 static void inno_hdmi_phy_rk3228_power_off(struct inno_hdmi_phy
*inno
)
952 inno_update_bits(inno
, 0xe1, RK3228_TMDS_DRIVER_ENABLE
, 0);
953 inno_update_bits(inno
, 0xe1, RK3228_BANDGAP_ENABLE
, 0);
954 inno_update_bits(inno
, 0xe0, RK3228_POST_PLL_POWER_DOWN
,
955 RK3228_POST_PLL_POWER_DOWN
);
958 static const struct inno_hdmi_phy_ops rk3228_hdmi_phy_ops
= {
959 .init
= inno_hdmi_phy_rk3228_init
,
960 .power_on
= inno_hdmi_phy_rk3228_power_on
,
961 .power_off
= inno_hdmi_phy_rk3228_power_off
,
964 static int inno_hdmi_phy_rk3328_init(struct inno_hdmi_phy
*inno
)
966 struct nvmem_cell
*cell
;
967 unsigned char *efuse_buf
;
971 * Use phy internal register control
972 * rxsense/poweron/pllpd/pdataen signal.
974 inno_write(inno
, 0x01, RK3328_BYPASS_RXSENSE_EN
|
975 RK3328_BYPASS_POWERON_EN
|
976 RK3328_BYPASS_PLLPD_EN
);
977 inno_write(inno
, 0x02, RK3328_INT_POL_HIGH
| RK3328_BYPASS_PDATA_EN
|
980 /* Disable phy irq */
981 inno_write(inno
, 0x05, 0);
982 inno_write(inno
, 0x07, 0);
984 /* try to read the chip-version */
985 inno
->chip_version
= 1;
986 cell
= nvmem_cell_get(inno
->dev
, "cpu-version");
988 if (PTR_ERR(cell
) == -EPROBE_DEFER
)
989 return -EPROBE_DEFER
;
994 efuse_buf
= nvmem_cell_read(cell
, &len
);
995 nvmem_cell_put(cell
);
997 if (IS_ERR(efuse_buf
))
1000 inno
->chip_version
= efuse_buf
[0] + 1;
1007 inno_hdmi_phy_rk3328_power_on(struct inno_hdmi_phy
*inno
,
1008 const struct post_pll_config
*cfg
,
1009 const struct phy_config
*phy_cfg
)
1014 inno_update_bits(inno
, 0x02, RK3328_PDATA_EN
, 0);
1015 inno_update_bits(inno
, 0xaa, RK3328_POST_PLL_POWER_DOWN
,
1016 RK3328_POST_PLL_POWER_DOWN
);
1018 inno_write(inno
, 0xac, RK3328_POST_PLL_FB_DIV_7_0(cfg
->fbdiv
));
1019 if (cfg
->postdiv
== 1) {
1020 inno_write(inno
, 0xaa, RK3328_POST_PLL_REFCLK_SEL_TMDS
);
1021 inno_write(inno
, 0xab, RK3328_POST_PLL_FB_DIV_8(cfg
->fbdiv
) |
1022 RK3328_POST_PLL_PRE_DIV(cfg
->prediv
));
1024 v
= (cfg
->postdiv
/ 2) - 1;
1025 v
&= RK3328_POST_PLL_POST_DIV_MASK
;
1026 inno_write(inno
, 0xad, v
);
1027 inno_write(inno
, 0xab, RK3328_POST_PLL_FB_DIV_8(cfg
->fbdiv
) |
1028 RK3328_POST_PLL_PRE_DIV(cfg
->prediv
));
1029 inno_write(inno
, 0xaa, RK3328_POST_PLL_POST_DIV_ENABLE
|
1030 RK3328_POST_PLL_REFCLK_SEL_TMDS
);
1033 for (v
= 0; v
< 14; v
++)
1034 inno_write(inno
, 0xb5 + v
, phy_cfg
->regs
[v
]);
1036 /* set ESD detection threshold for TMDS CLK, D2, D1 and D0 */
1037 for (v
= 0; v
< 4; v
++)
1038 inno_update_bits(inno
, 0xc8 + v
, RK3328_ESD_DETECT_MASK
,
1039 RK3328_ESD_DETECT_340MV
);
1041 if (phy_cfg
->tmdsclock
> 340000000) {
1042 /* Set termination resistor to 100ohm */
1043 v
= clk_get_rate(inno
->sysclk
) / 100000;
1044 inno_write(inno
, 0xc5, RK3328_TERM_RESISTOR_CALIB_SPEED_14_8(v
)
1045 | RK3328_BYPASS_TERM_RESISTOR_CALIB
);
1046 inno_write(inno
, 0xc6, RK3328_TERM_RESISTOR_CALIB_SPEED_7_0(v
));
1047 inno_write(inno
, 0xc7, RK3328_TERM_RESISTOR_100
);
1048 inno_update_bits(inno
, 0xc5,
1049 RK3328_BYPASS_TERM_RESISTOR_CALIB
, 0);
1051 inno_write(inno
, 0xc5, RK3328_BYPASS_TERM_RESISTOR_CALIB
);
1053 /* clk termination resistor is 50ohm (parallel resistors) */
1054 if (phy_cfg
->tmdsclock
> 165000000)
1055 inno_update_bits(inno
, 0xc8,
1056 RK3328_TMDS_TERM_RESIST_MASK
,
1057 RK3328_TMDS_TERM_RESIST_75
|
1058 RK3328_TMDS_TERM_RESIST_150
);
1060 /* data termination resistor for D2, D1 and D0 is 150ohm */
1061 for (v
= 0; v
< 3; v
++)
1062 inno_update_bits(inno
, 0xc9 + v
,
1063 RK3328_TMDS_TERM_RESIST_MASK
,
1064 RK3328_TMDS_TERM_RESIST_150
);
1067 inno_update_bits(inno
, 0xaa, RK3328_POST_PLL_POWER_DOWN
, 0);
1068 inno_update_bits(inno
, 0xb0, RK3328_BANDGAP_ENABLE
,
1069 RK3328_BANDGAP_ENABLE
);
1070 inno_update_bits(inno
, 0xb2, RK3328_TMDS_DRIVER_ENABLE
,
1071 RK3328_TMDS_DRIVER_ENABLE
);
1073 /* Wait for post PLL lock */
1074 ret
= inno_poll(inno
, 0xaf, v
, v
& RK3328_POST_PLL_LOCK_STATUS
,
1077 dev_err(inno
->dev
, "Post-PLL locking failed\n");
1081 if (phy_cfg
->tmdsclock
> 340000000)
1084 inno_update_bits(inno
, 0x02, RK3328_PDATA_EN
, RK3328_PDATA_EN
);
1086 /* Enable PHY IRQ */
1087 inno_write(inno
, 0x05, RK3328_INT_TMDS_CLK(RK3328_INT_VSS_AGND_ESD_DET
)
1088 | RK3328_INT_TMDS_D2(RK3328_INT_VSS_AGND_ESD_DET
));
1089 inno_write(inno
, 0x07, RK3328_INT_TMDS_D1(RK3328_INT_VSS_AGND_ESD_DET
)
1090 | RK3328_INT_TMDS_D0(RK3328_INT_VSS_AGND_ESD_DET
));
1094 static void inno_hdmi_phy_rk3328_power_off(struct inno_hdmi_phy
*inno
)
1096 inno_update_bits(inno
, 0xb2, RK3328_TMDS_DRIVER_ENABLE
, 0);
1097 inno_update_bits(inno
, 0xb0, RK3328_BANDGAP_ENABLE
, 0);
1098 inno_update_bits(inno
, 0xaa, RK3328_POST_PLL_POWER_DOWN
,
1099 RK3328_POST_PLL_POWER_DOWN
);
1101 /* Disable PHY IRQ */
1102 inno_write(inno
, 0x05, 0);
1103 inno_write(inno
, 0x07, 0);
1106 static const struct inno_hdmi_phy_ops rk3328_hdmi_phy_ops
= {
1107 .init
= inno_hdmi_phy_rk3328_init
,
1108 .power_on
= inno_hdmi_phy_rk3328_power_on
,
1109 .power_off
= inno_hdmi_phy_rk3328_power_off
,
1112 static const struct inno_hdmi_phy_drv_data rk3228_hdmi_phy_drv_data
= {
1113 .ops
= &rk3228_hdmi_phy_ops
,
1114 .clk_ops
= &inno_hdmi_phy_rk3228_clk_ops
,
1115 .phy_cfg_table
= rk3228_phy_cfg
,
1118 static const struct inno_hdmi_phy_drv_data rk3328_hdmi_phy_drv_data
= {
1119 .ops
= &rk3328_hdmi_phy_ops
,
1120 .clk_ops
= &inno_hdmi_phy_rk3328_clk_ops
,
1121 .phy_cfg_table
= rk3328_phy_cfg
,
1124 static const struct regmap_config inno_hdmi_phy_regmap_config
= {
1128 .max_register
= 0x400,
1131 static void inno_hdmi_phy_action(void *data
)
1133 struct inno_hdmi_phy
*inno
= data
;
1135 clk_disable_unprepare(inno
->refpclk
);
1136 clk_disable_unprepare(inno
->sysclk
);
1139 static int inno_hdmi_phy_probe(struct platform_device
*pdev
)
1141 struct inno_hdmi_phy
*inno
;
1142 struct phy_provider
*phy_provider
;
1143 struct resource
*res
;
1147 inno
= devm_kzalloc(&pdev
->dev
, sizeof(*inno
), GFP_KERNEL
);
1151 inno
->dev
= &pdev
->dev
;
1153 inno
->plat_data
= of_device_get_match_data(inno
->dev
);
1154 if (!inno
->plat_data
|| !inno
->plat_data
->ops
)
1157 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1158 regs
= devm_ioremap_resource(inno
->dev
, res
);
1160 return PTR_ERR(regs
);
1162 inno
->sysclk
= devm_clk_get(inno
->dev
, "sysclk");
1163 if (IS_ERR(inno
->sysclk
)) {
1164 ret
= PTR_ERR(inno
->sysclk
);
1165 dev_err(inno
->dev
, "failed to get sysclk: %d\n", ret
);
1169 inno
->refpclk
= devm_clk_get(inno
->dev
, "refpclk");
1170 if (IS_ERR(inno
->refpclk
)) {
1171 ret
= PTR_ERR(inno
->refpclk
);
1172 dev_err(inno
->dev
, "failed to get ref clock: %d\n", ret
);
1176 inno
->refoclk
= devm_clk_get(inno
->dev
, "refoclk");
1177 if (IS_ERR(inno
->refoclk
)) {
1178 ret
= PTR_ERR(inno
->refoclk
);
1179 dev_err(inno
->dev
, "failed to get oscillator-ref clock: %d\n",
1184 ret
= clk_prepare_enable(inno
->sysclk
);
1186 dev_err(inno
->dev
, "Cannot enable inno phy sysclk: %d\n", ret
);
1191 * Refpclk needs to be on, on at least the rk3328 for still
1194 ret
= clk_prepare_enable(inno
->refpclk
);
1196 dev_err(inno
->dev
, "failed to enable refpclk\n");
1197 clk_disable_unprepare(inno
->sysclk
);
1201 ret
= devm_add_action_or_reset(inno
->dev
, inno_hdmi_phy_action
,
1206 inno
->regmap
= devm_regmap_init_mmio(inno
->dev
, regs
,
1207 &inno_hdmi_phy_regmap_config
);
1208 if (IS_ERR(inno
->regmap
))
1209 return PTR_ERR(inno
->regmap
);
1211 /* only the newer rk3328 hdmiphy has an interrupt */
1212 inno
->irq
= platform_get_irq(pdev
, 0);
1213 if (inno
->irq
> 0) {
1214 ret
= devm_request_threaded_irq(inno
->dev
, inno
->irq
,
1215 inno_hdmi_phy_rk3328_hardirq
,
1216 inno_hdmi_phy_rk3328_irq
,
1218 dev_name(inno
->dev
), inno
);
1223 inno
->phy
= devm_phy_create(inno
->dev
, NULL
, &inno_hdmi_phy_ops
);
1224 if (IS_ERR(inno
->phy
)) {
1225 dev_err(inno
->dev
, "failed to create HDMI PHY\n");
1226 return PTR_ERR(inno
->phy
);
1229 phy_set_drvdata(inno
->phy
, inno
);
1230 phy_set_bus_width(inno
->phy
, 8);
1232 if (inno
->plat_data
->ops
->init
) {
1233 ret
= inno
->plat_data
->ops
->init(inno
);
1238 ret
= inno_hdmi_phy_clk_register(inno
);
1242 phy_provider
= devm_of_phy_provider_register(inno
->dev
,
1243 of_phy_simple_xlate
);
1244 return PTR_ERR_OR_ZERO(phy_provider
);
1247 static int inno_hdmi_phy_remove(struct platform_device
*pdev
)
1249 of_clk_del_provider(pdev
->dev
.of_node
);
1254 static const struct of_device_id inno_hdmi_phy_of_match
[] = {
1256 .compatible
= "rockchip,rk3228-hdmi-phy",
1257 .data
= &rk3228_hdmi_phy_drv_data
1259 .compatible
= "rockchip,rk3328-hdmi-phy",
1260 .data
= &rk3328_hdmi_phy_drv_data
1261 }, { /* sentinel */ }
1263 MODULE_DEVICE_TABLE(of
, inno_hdmi_phy_of_match
);
1265 static struct platform_driver inno_hdmi_phy_driver
= {
1266 .probe
= inno_hdmi_phy_probe
,
1267 .remove
= inno_hdmi_phy_remove
,
1269 .name
= "inno-hdmi-phy",
1270 .of_match_table
= inno_hdmi_phy_of_match
,
1273 module_platform_driver(inno_hdmi_phy_driver
);
1275 MODULE_AUTHOR("Zheng Yang <zhengyang@rock-chips.com>");
1276 MODULE_DESCRIPTION("Innosilion HDMI 2.0 Transmitter PHY Driver");
1277 MODULE_LICENSE("GPL v2");