1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright 2017,2018 NXP
4  * Copyright 2019 Purism SPC
5  */
6 
7 #include <linux/bitfield.h>
8 #include <linux/clk.h>
9 #include <linux/clk-provider.h>
10 #include <linux/delay.h>
11 #include <linux/firmware/imx/ipc.h>
12 #include <linux/firmware/imx/svc/misc.h>
13 #include <linux/io.h>
14 #include <linux/kernel.h>
15 #include <linux/mfd/syscon.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/of_platform.h>
19 #include <linux/phy/phy.h>
20 #include <linux/platform_device.h>
21 #include <linux/regmap.h>
22 #include <dt-bindings/firmware/imx/rsrc.h>
23 
24 /* Control and Status Registers(CSR) */
25 #define PHY_CTRL			0x00
26 #define  CCM_MASK			GENMASK(7, 5)
27 #define  CCM(n)				FIELD_PREP(CCM_MASK, (n))
28 #define  CCM_1_2V			0x5
29 #define  CA_MASK			GENMASK(4, 2)
30 #define  CA_3_51MA			0x4
31 #define  CA(n)				FIELD_PREP(CA_MASK, (n))
32 #define  RFB				BIT(1)
33 #define  LVDS_EN			BIT(0)
34 
35 /* DPHY registers */
36 #define DPHY_PD_DPHY			0x00
37 #define DPHY_M_PRG_HS_PREPARE		0x04
38 #define DPHY_MC_PRG_HS_PREPARE		0x08
39 #define DPHY_M_PRG_HS_ZERO		0x0c
40 #define DPHY_MC_PRG_HS_ZERO		0x10
41 #define DPHY_M_PRG_HS_TRAIL		0x14
42 #define DPHY_MC_PRG_HS_TRAIL		0x18
43 #define DPHY_PD_PLL			0x1c
44 #define DPHY_TST			0x20
45 #define DPHY_CN				0x24
46 #define DPHY_CM				0x28
47 #define DPHY_CO				0x2c
48 #define DPHY_LOCK			0x30
49 #define DPHY_LOCK_BYP			0x34
50 #define DPHY_REG_BYPASS_PLL		0x4C
51 
52 #define MBPS(x) ((x) * 1000000)
53 
54 #define DATA_RATE_MAX_SPEED MBPS(1500)
55 #define DATA_RATE_MIN_SPEED MBPS(80)
56 
57 #define PLL_LOCK_SLEEP 10
58 #define PLL_LOCK_TIMEOUT 1000
59 
60 #define CN_BUF	0xcb7a89c0
61 #define CO_BUF	0x63
62 #define CM(x)	(				  \
63 		((x) <	32) ? 0xe0 | ((x) - 16) : \
64 		((x) <	64) ? 0xc0 | ((x) - 32) : \
65 		((x) < 128) ? 0x80 | ((x) - 64) : \
66 		((x) - 128))
67 #define CN(x)	(((x) == 1) ? 0x1f : (((CN_BUF) >> ((x) - 1)) & 0x1f))
68 #define CO(x)	((CO_BUF) >> (8 - (x)) & 0x03)
69 
70 /* PHY power on is active low */
71 #define PWR_ON	0
72 #define PWR_OFF	1
73 
74 #define MIN_VCO_FREQ 640000000
75 #define MAX_VCO_FREQ 1500000000
76 
77 #define MIN_LVDS_REFCLK_FREQ 24000000
78 #define MAX_LVDS_REFCLK_FREQ 150000000
79 
80 enum mixel_dphy_devtype {
81 	MIXEL_IMX8MQ,
82 	MIXEL_IMX8QXP,
83 };
84 
85 struct mixel_dphy_devdata {
86 	u8 reg_tx_rcal;
87 	u8 reg_auto_pd_en;
88 	u8 reg_rxlprp;
89 	u8 reg_rxcdrp;
90 	u8 reg_rxhs_settle;
91 	bool is_combo;	/* MIPI DPHY and LVDS PHY combo */
92 };
93 
94 static const struct mixel_dphy_devdata mixel_dphy_devdata[] = {
95 	[MIXEL_IMX8MQ] = {
96 		.reg_tx_rcal = 0x38,
97 		.reg_auto_pd_en = 0x3c,
98 		.reg_rxlprp = 0x40,
99 		.reg_rxcdrp = 0x44,
100 		.reg_rxhs_settle = 0x48,
101 		.is_combo = false,
102 	},
103 	[MIXEL_IMX8QXP] = {
104 		.is_combo = true,
105 	},
106 };
107 
108 struct mixel_dphy_cfg {
109 	/* DPHY PLL parameters */
110 	u32 cm;
111 	u32 cn;
112 	u32 co;
113 	/* DPHY register values */
114 	u8 mc_prg_hs_prepare;
115 	u8 m_prg_hs_prepare;
116 	u8 mc_prg_hs_zero;
117 	u8 m_prg_hs_zero;
118 	u8 mc_prg_hs_trail;
119 	u8 m_prg_hs_trail;
120 	u8 rxhs_settle;
121 };
122 
123 struct mixel_dphy_priv {
124 	struct mixel_dphy_cfg cfg;
125 	struct regmap *regmap;
126 	struct regmap *lvds_regmap;
127 	struct clk *phy_ref_clk;
128 	const struct mixel_dphy_devdata *devdata;
129 	struct imx_sc_ipc *ipc_handle;
130 	bool is_slave;
131 	int id;
132 };
133 
134 static const struct regmap_config mixel_dphy_regmap_config = {
135 	.reg_bits = 8,
136 	.val_bits = 32,
137 	.reg_stride = 4,
138 	.max_register = DPHY_REG_BYPASS_PLL,
139 	.name = "mipi-dphy",
140 };
141 
142 static int phy_write(struct phy *phy, u32 value, unsigned int reg)
143 {
144 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
145 	int ret;
146 
147 	ret = regmap_write(priv->regmap, reg, value);
148 	if (ret < 0)
149 		dev_err(&phy->dev, "Failed to write DPHY reg %d: %d\n", reg,
150 			ret);
151 	return ret;
152 }
153 
154 /*
155  * Find a ratio close to the desired one using continued fraction
156  * approximation ending either at exact match or maximum allowed
157  * nominator, denominator.
158  */
159 static void get_best_ratio(u32 *pnum, u32 *pdenom, u32 max_n, u32 max_d)
160 {
161 	u32 a = *pnum;
162 	u32 b = *pdenom;
163 	u32 c;
164 	u32 n[] = {0, 1};
165 	u32 d[] = {1, 0};
166 	u32 whole;
167 	unsigned int i = 1;
168 
169 	while (b) {
170 		i ^= 1;
171 		whole = a / b;
172 		n[i] += (n[i ^ 1] * whole);
173 		d[i] += (d[i ^ 1] * whole);
174 		if ((n[i] > max_n) || (d[i] > max_d)) {
175 			i ^= 1;
176 			break;
177 		}
178 		c = a - (b * whole);
179 		a = b;
180 		b = c;
181 	}
182 	*pnum = n[i];
183 	*pdenom = d[i];
184 }
185 
186 static int mixel_dphy_config_from_opts(struct phy *phy,
187 	       struct phy_configure_opts_mipi_dphy *dphy_opts,
188 	       struct mixel_dphy_cfg *cfg)
189 {
190 	struct mixel_dphy_priv *priv = dev_get_drvdata(phy->dev.parent);
191 	unsigned long ref_clk = clk_get_rate(priv->phy_ref_clk);
192 	u32 lp_t, numerator, denominator;
193 	unsigned long long tmp;
194 	u32 n;
195 	int i;
196 
197 	if (dphy_opts->hs_clk_rate > DATA_RATE_MAX_SPEED ||
198 	    dphy_opts->hs_clk_rate < DATA_RATE_MIN_SPEED)
199 		return -EINVAL;
200 
201 	numerator = dphy_opts->hs_clk_rate;
202 	denominator = ref_clk;
203 	get_best_ratio(&numerator, &denominator, 255, 256);
204 	if (!numerator || !denominator) {
205 		dev_err(&phy->dev, "Invalid %d/%d for %ld/%ld\n",
206 			numerator, denominator,
207 			dphy_opts->hs_clk_rate, ref_clk);
208 		return -EINVAL;
209 	}
210 
211 	while ((numerator < 16) && (denominator <= 128)) {
212 		numerator <<= 1;
213 		denominator <<= 1;
214 	}
215 	/*
216 	 * CM ranges between 16 and 255
217 	 * CN ranges between 1 and 32
218 	 * CO is power of 2: 1, 2, 4, 8
219 	 */
220 	i = __ffs(denominator);
221 	if (i > 3)
222 		i = 3;
223 	cfg->cn = denominator >> i;
224 	cfg->co = 1 << i;
225 	cfg->cm = numerator;
226 
227 	if (cfg->cm < 16 || cfg->cm > 255 ||
228 	    cfg->cn < 1 || cfg->cn > 32 ||
229 	    cfg->co < 1 || cfg->co > 8) {
230 		dev_err(&phy->dev, "Invalid CM/CN/CO values: %u/%u/%u\n",
231 			cfg->cm, cfg->cn, cfg->co);
232 		dev_err(&phy->dev, "for hs_clk/ref_clk=%ld/%ld ~ %d/%d\n",
233 			dphy_opts->hs_clk_rate, ref_clk,
234 			numerator, denominator);
235 		return -EINVAL;
236 	}
237 
238 	dev_dbg(&phy->dev, "hs_clk/ref_clk=%ld/%ld ~ %d/%d\n",
239 		dphy_opts->hs_clk_rate, ref_clk, numerator, denominator);
240 
241 	/* LP clock period */
242 	tmp = 1000000000000LL;
243 	do_div(tmp, dphy_opts->lp_clk_rate); /* ps */
244 	if (tmp > ULONG_MAX)
245 		return -EINVAL;
246 
247 	lp_t = tmp;
248 	dev_dbg(&phy->dev, "LP clock %lu, period: %u ps\n",
249 		dphy_opts->lp_clk_rate, lp_t);
250 
251 	/* hs_prepare: in lp clock periods */
252 	if (2 * dphy_opts->hs_prepare > 5 * lp_t) {
253 		dev_err(&phy->dev,
254 			"hs_prepare (%u) > 2.5 * lp clock period (%u)\n",
255 			dphy_opts->hs_prepare, lp_t);
256 		return -EINVAL;
257 	}
258 	/* 00: lp_t, 01: 1.5 * lp_t, 10: 2 * lp_t, 11: 2.5 * lp_t */
259 	if (dphy_opts->hs_prepare < lp_t) {
260 		n = 0;
261 	} else {
262 		tmp = 2 * (dphy_opts->hs_prepare - lp_t);
263 		do_div(tmp, lp_t);
264 		n = tmp;
265 	}
266 	cfg->m_prg_hs_prepare = n;
267 
268 	/* clk_prepare: in lp clock periods */
269 	if (2 * dphy_opts->clk_prepare > 3 * lp_t) {
270 		dev_err(&phy->dev,
271 			"clk_prepare (%u) > 1.5 * lp clock period (%u)\n",
272 			dphy_opts->clk_prepare, lp_t);
273 		return -EINVAL;
274 	}
275 	/* 00: lp_t, 01: 1.5 * lp_t */
276 	cfg->mc_prg_hs_prepare = dphy_opts->clk_prepare > lp_t ? 1 : 0;
277 
278 	/* hs_zero: formula from NXP BSP */
279 	n = (144 * (dphy_opts->hs_clk_rate / 1000000) - 47500) / 10000;
280 	cfg->m_prg_hs_zero = n < 1 ? 1 : n;
281 
282 	/* clk_zero: formula from NXP BSP */
283 	n = (34 * (dphy_opts->hs_clk_rate / 1000000) - 2500) / 1000;
284 	cfg->mc_prg_hs_zero = n < 1 ? 1 : n;
285 
286 	/* clk_trail, hs_trail: formula from NXP BSP */
287 	n = (103 * (dphy_opts->hs_clk_rate / 1000000) + 10000) / 10000;
288 	if (n > 15)
289 		n = 15;
290 	if (n < 1)
291 		n = 1;
292 	cfg->m_prg_hs_trail = n;
293 	cfg->mc_prg_hs_trail = n;
294 
295 	/* rxhs_settle: formula from NXP BSP */
296 	if (dphy_opts->hs_clk_rate < MBPS(80))
297 		cfg->rxhs_settle = 0x0d;
298 	else if (dphy_opts->hs_clk_rate < MBPS(90))
299 		cfg->rxhs_settle = 0x0c;
300 	else if (dphy_opts->hs_clk_rate < MBPS(125))
301 		cfg->rxhs_settle = 0x0b;
302 	else if (dphy_opts->hs_clk_rate < MBPS(150))
303 		cfg->rxhs_settle = 0x0a;
304 	else if (dphy_opts->hs_clk_rate < MBPS(225))
305 		cfg->rxhs_settle = 0x09;
306 	else if (dphy_opts->hs_clk_rate < MBPS(500))
307 		cfg->rxhs_settle = 0x08;
308 	else
309 		cfg->rxhs_settle = 0x07;
310 
311 	dev_dbg(&phy->dev, "phy_config: %u %u %u %u %u %u %u\n",
312 		cfg->m_prg_hs_prepare, cfg->mc_prg_hs_prepare,
313 		cfg->m_prg_hs_zero, cfg->mc_prg_hs_zero,
314 		cfg->m_prg_hs_trail, cfg->mc_prg_hs_trail,
315 		cfg->rxhs_settle);
316 
317 	return 0;
318 }
319 
320 static void mixel_phy_set_hs_timings(struct phy *phy)
321 {
322 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
323 
324 	phy_write(phy, priv->cfg.m_prg_hs_prepare, DPHY_M_PRG_HS_PREPARE);
325 	phy_write(phy, priv->cfg.mc_prg_hs_prepare, DPHY_MC_PRG_HS_PREPARE);
326 	phy_write(phy, priv->cfg.m_prg_hs_zero, DPHY_M_PRG_HS_ZERO);
327 	phy_write(phy, priv->cfg.mc_prg_hs_zero, DPHY_MC_PRG_HS_ZERO);
328 	phy_write(phy, priv->cfg.m_prg_hs_trail, DPHY_M_PRG_HS_TRAIL);
329 	phy_write(phy, priv->cfg.mc_prg_hs_trail, DPHY_MC_PRG_HS_TRAIL);
330 	phy_write(phy, priv->cfg.rxhs_settle, priv->devdata->reg_rxhs_settle);
331 }
332 
333 static int mixel_dphy_set_pll_params(struct phy *phy)
334 {
335 	struct mixel_dphy_priv *priv = dev_get_drvdata(phy->dev.parent);
336 
337 	if (priv->cfg.cm < 16 || priv->cfg.cm > 255 ||
338 	    priv->cfg.cn < 1 || priv->cfg.cn > 32 ||
339 	    priv->cfg.co < 1 || priv->cfg.co > 8) {
340 		dev_err(&phy->dev, "Invalid CM/CN/CO values! (%u/%u/%u)\n",
341 			priv->cfg.cm, priv->cfg.cn, priv->cfg.co);
342 		return -EINVAL;
343 	}
344 	dev_dbg(&phy->dev, "Using CM:%u CN:%u CO:%u\n",
345 		priv->cfg.cm, priv->cfg.cn, priv->cfg.co);
346 	phy_write(phy, CM(priv->cfg.cm), DPHY_CM);
347 	phy_write(phy, CN(priv->cfg.cn), DPHY_CN);
348 	phy_write(phy, CO(priv->cfg.co), DPHY_CO);
349 	return 0;
350 }
351 
352 static int
353 mixel_dphy_configure_mipi_dphy(struct phy *phy, union phy_configure_opts *opts)
354 {
355 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
356 	struct mixel_dphy_cfg cfg = { 0 };
357 	int ret;
358 
359 	ret = mixel_dphy_config_from_opts(phy, &opts->mipi_dphy, &cfg);
360 	if (ret)
361 		return ret;
362 
363 	/* Update the configuration */
364 	memcpy(&priv->cfg, &cfg, sizeof(struct mixel_dphy_cfg));
365 
366 	phy_write(phy, 0x00, DPHY_LOCK_BYP);
367 	phy_write(phy, 0x01, priv->devdata->reg_tx_rcal);
368 	phy_write(phy, 0x00, priv->devdata->reg_auto_pd_en);
369 	phy_write(phy, 0x02, priv->devdata->reg_rxlprp);
370 	phy_write(phy, 0x02, priv->devdata->reg_rxcdrp);
371 	phy_write(phy, 0x25, DPHY_TST);
372 
373 	mixel_phy_set_hs_timings(phy);
374 	ret = mixel_dphy_set_pll_params(phy);
375 	if (ret < 0)
376 		return ret;
377 
378 	return 0;
379 }
380 
381 static int
382 mixel_dphy_configure_lvds_phy(struct phy *phy, union phy_configure_opts *opts)
383 {
384 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
385 	struct phy_configure_opts_lvds *lvds_opts = &opts->lvds;
386 	unsigned long data_rate;
387 	unsigned long fvco;
388 	u32 rsc;
389 	u32 co;
390 	int ret;
391 
392 	priv->is_slave = lvds_opts->is_slave;
393 
394 	/* LVDS interface pins */
395 	regmap_write(priv->lvds_regmap, PHY_CTRL,
396 		     CCM(CCM_1_2V) | CA(CA_3_51MA) | RFB);
397 
398 	/* enable MODE8 only for slave LVDS PHY */
399 	rsc = priv->id ? IMX_SC_R_MIPI_1 : IMX_SC_R_MIPI_0;
400 	ret = imx_sc_misc_set_control(priv->ipc_handle, rsc, IMX_SC_C_DUAL_MODE,
401 				      lvds_opts->is_slave);
402 	if (ret) {
403 		dev_err(&phy->dev, "Failed to configure MODE8: %d\n", ret);
404 		return ret;
405 	}
406 
407 	/*
408 	 * Choose an appropriate divider ratio to meet the requirement of
409 	 * PLL VCO frequency range.
410 	 *
411 	 *  -----  640MHz ~ 1500MHz   ------------      ---------------
412 	 * | VCO | ----------------> | CO divider | -> | LVDS data rate|
413 	 *  -----       FVCO          ------------      ---------------
414 	 *                            1/2/4/8 div     7 * differential_clk_rate
415 	 */
416 	data_rate = 7 * lvds_opts->differential_clk_rate;
417 	for (co = 1; co <= 8; co *= 2) {
418 		fvco = data_rate * co;
419 
420 		if (fvco >= MIN_VCO_FREQ)
421 			break;
422 	}
423 
424 	if (fvco < MIN_VCO_FREQ || fvco > MAX_VCO_FREQ) {
425 		dev_err(&phy->dev, "VCO frequency %lu is out of range\n", fvco);
426 		return -ERANGE;
427 	}
428 
429 	/*
430 	 * CO is configurable, while CN and CM are not,
431 	 * as fixed ratios 1 and 7 are applied respectively.
432 	 */
433 	phy_write(phy, __ffs(co), DPHY_CO);
434 
435 	/* set reference clock rate */
436 	clk_set_rate(priv->phy_ref_clk, lvds_opts->differential_clk_rate);
437 
438 	return ret;
439 }
440 
441 static int mixel_dphy_configure(struct phy *phy, union phy_configure_opts *opts)
442 {
443 	if (!opts) {
444 		dev_err(&phy->dev, "No configuration options\n");
445 		return -EINVAL;
446 	}
447 
448 	if (phy->attrs.mode == PHY_MODE_MIPI_DPHY)
449 		return mixel_dphy_configure_mipi_dphy(phy, opts);
450 	else if (phy->attrs.mode == PHY_MODE_LVDS)
451 		return mixel_dphy_configure_lvds_phy(phy, opts);
452 
453 	dev_err(&phy->dev,
454 		"Failed to configure PHY with invalid PHY mode: %d\n", phy->attrs.mode);
455 
456 	return -EINVAL;
457 }
458 
459 static int
460 mixel_dphy_validate_lvds_phy(struct phy *phy, union phy_configure_opts *opts)
461 {
462 	struct phy_configure_opts_lvds *lvds_cfg = &opts->lvds;
463 
464 	if (lvds_cfg->bits_per_lane_and_dclk_cycle != 7) {
465 		dev_err(&phy->dev, "Invalid bits per LVDS data lane: %u\n",
466 			lvds_cfg->bits_per_lane_and_dclk_cycle);
467 		return -EINVAL;
468 	}
469 
470 	if (lvds_cfg->lanes != 4) {
471 		dev_err(&phy->dev, "Invalid LVDS data lanes: %u\n", lvds_cfg->lanes);
472 		return -EINVAL;
473 	}
474 
475 	if (lvds_cfg->differential_clk_rate < MIN_LVDS_REFCLK_FREQ ||
476 	    lvds_cfg->differential_clk_rate > MAX_LVDS_REFCLK_FREQ) {
477 		dev_err(&phy->dev,
478 			"Invalid LVDS differential clock rate: %lu\n",
479 			lvds_cfg->differential_clk_rate);
480 		return -EINVAL;
481 	}
482 
483 	return 0;
484 }
485 
486 static int mixel_dphy_validate(struct phy *phy, enum phy_mode mode, int submode,
487 			       union phy_configure_opts *opts)
488 {
489 	if (mode == PHY_MODE_MIPI_DPHY) {
490 		struct mixel_dphy_cfg mipi_dphy_cfg = { 0 };
491 
492 		return mixel_dphy_config_from_opts(phy, &opts->mipi_dphy,
493 						   &mipi_dphy_cfg);
494 	} else if (mode == PHY_MODE_LVDS) {
495 		return mixel_dphy_validate_lvds_phy(phy, opts);
496 	}
497 
498 	dev_err(&phy->dev,
499 		"Failed to validate PHY with invalid PHY mode: %d\n", mode);
500 	return -EINVAL;
501 }
502 
503 static int mixel_dphy_init(struct phy *phy)
504 {
505 	phy_write(phy, PWR_OFF, DPHY_PD_PLL);
506 	phy_write(phy, PWR_OFF, DPHY_PD_DPHY);
507 
508 	return 0;
509 }
510 
511 static int mixel_dphy_exit(struct phy *phy)
512 {
513 	phy_write(phy, 0, DPHY_CM);
514 	phy_write(phy, 0, DPHY_CN);
515 	phy_write(phy, 0, DPHY_CO);
516 
517 	return 0;
518 }
519 
520 static int mixel_dphy_power_on_mipi_dphy(struct phy *phy)
521 {
522 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
523 	u32 locked;
524 	int ret;
525 
526 	phy_write(phy, PWR_ON, DPHY_PD_PLL);
527 	ret = regmap_read_poll_timeout(priv->regmap, DPHY_LOCK, locked,
528 				       locked, PLL_LOCK_SLEEP,
529 				       PLL_LOCK_TIMEOUT);
530 	if (ret < 0) {
531 		dev_err(&phy->dev, "Could not get DPHY lock (%d)!\n", ret);
532 		return ret;
533 	}
534 	phy_write(phy, PWR_ON, DPHY_PD_DPHY);
535 
536 	return 0;
537 }
538 
539 static int mixel_dphy_power_on_lvds_phy(struct phy *phy)
540 {
541 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
542 	u32 locked;
543 	int ret;
544 
545 	regmap_update_bits(priv->lvds_regmap, PHY_CTRL, LVDS_EN, LVDS_EN);
546 
547 	phy_write(phy, PWR_ON, DPHY_PD_DPHY);
548 	phy_write(phy, PWR_ON, DPHY_PD_PLL);
549 
550 	/* do not wait for slave LVDS PHY being locked */
551 	if (priv->is_slave)
552 		return 0;
553 
554 	ret = regmap_read_poll_timeout(priv->regmap, DPHY_LOCK, locked,
555 				       locked, PLL_LOCK_SLEEP,
556 				       PLL_LOCK_TIMEOUT);
557 	if (ret < 0) {
558 		dev_err(&phy->dev, "Could not get LVDS PHY lock (%d)!\n", ret);
559 		return ret;
560 	}
561 
562 	return 0;
563 }
564 
565 static int mixel_dphy_power_on(struct phy *phy)
566 {
567 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
568 	int ret;
569 
570 	ret = clk_prepare_enable(priv->phy_ref_clk);
571 	if (ret < 0)
572 		return ret;
573 
574 	if (phy->attrs.mode == PHY_MODE_MIPI_DPHY) {
575 		ret = mixel_dphy_power_on_mipi_dphy(phy);
576 	} else if (phy->attrs.mode == PHY_MODE_LVDS) {
577 		ret = mixel_dphy_power_on_lvds_phy(phy);
578 	} else {
579 		dev_err(&phy->dev,
580 			"Failed to power on PHY with invalid PHY mode: %d\n",
581 							phy->attrs.mode);
582 		ret = -EINVAL;
583 	}
584 
585 	if (ret)
586 		goto clock_disable;
587 
588 	return 0;
589 clock_disable:
590 	clk_disable_unprepare(priv->phy_ref_clk);
591 	return ret;
592 }
593 
594 static int mixel_dphy_power_off(struct phy *phy)
595 {
596 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
597 
598 	phy_write(phy, PWR_OFF, DPHY_PD_PLL);
599 	phy_write(phy, PWR_OFF, DPHY_PD_DPHY);
600 
601 	if (phy->attrs.mode == PHY_MODE_LVDS)
602 		regmap_update_bits(priv->lvds_regmap, PHY_CTRL, LVDS_EN, 0);
603 
604 	clk_disable_unprepare(priv->phy_ref_clk);
605 
606 	return 0;
607 }
608 
609 static int mixel_dphy_set_mode(struct phy *phy, enum phy_mode mode, int submode)
610 {
611 	struct mixel_dphy_priv *priv = phy_get_drvdata(phy);
612 	int ret;
613 
614 	if (priv->devdata->is_combo && mode != PHY_MODE_LVDS) {
615 		dev_err(&phy->dev, "Failed to set PHY mode for combo PHY\n");
616 		return -EINVAL;
617 	}
618 
619 	if (!priv->devdata->is_combo && mode != PHY_MODE_MIPI_DPHY) {
620 		dev_err(&phy->dev, "Failed to set PHY mode to MIPI DPHY\n");
621 		return -EINVAL;
622 	}
623 
624 	if (priv->devdata->is_combo) {
625 		u32 rsc = priv->id ? IMX_SC_R_MIPI_1 : IMX_SC_R_MIPI_0;
626 
627 		ret = imx_sc_misc_set_control(priv->ipc_handle,
628 					      rsc, IMX_SC_C_MODE,
629 					      mode == PHY_MODE_LVDS);
630 		if (ret) {
631 			dev_err(&phy->dev,
632 				"Failed to set PHY mode via SCU ipc: %d\n", ret);
633 			return ret;
634 		}
635 	}
636 
637 	return 0;
638 }
639 
640 static const struct phy_ops mixel_dphy_phy_ops = {
641 	.init = mixel_dphy_init,
642 	.exit = mixel_dphy_exit,
643 	.power_on = mixel_dphy_power_on,
644 	.power_off = mixel_dphy_power_off,
645 	.set_mode = mixel_dphy_set_mode,
646 	.configure = mixel_dphy_configure,
647 	.validate = mixel_dphy_validate,
648 	.owner = THIS_MODULE,
649 };
650 
651 static const struct of_device_id mixel_dphy_of_match[] = {
652 	{ .compatible = "fsl,imx8mq-mipi-dphy",
653 	  .data = &mixel_dphy_devdata[MIXEL_IMX8MQ] },
654 	{ .compatible = "fsl,imx8qxp-mipi-dphy",
655 	  .data = &mixel_dphy_devdata[MIXEL_IMX8QXP] },
656 	{ /* sentinel */ },
657 };
658 MODULE_DEVICE_TABLE(of, mixel_dphy_of_match);
659 
660 static int mixel_dphy_probe(struct platform_device *pdev)
661 {
662 	struct device *dev = &pdev->dev;
663 	struct device_node *np = dev->of_node;
664 	struct phy_provider *phy_provider;
665 	struct mixel_dphy_priv *priv;
666 	struct phy *phy;
667 	void __iomem *base;
668 	int ret;
669 
670 	if (!np)
671 		return -ENODEV;
672 
673 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
674 	if (!priv)
675 		return -ENOMEM;
676 
677 	priv->devdata = of_device_get_match_data(&pdev->dev);
678 	if (!priv->devdata)
679 		return -EINVAL;
680 
681 	base = devm_platform_ioremap_resource(pdev, 0);
682 	if (IS_ERR(base))
683 		return PTR_ERR(base);
684 
685 	priv->regmap = devm_regmap_init_mmio(&pdev->dev, base,
686 					     &mixel_dphy_regmap_config);
687 	if (IS_ERR(priv->regmap)) {
688 		dev_err(dev, "Couldn't create the DPHY regmap\n");
689 		return PTR_ERR(priv->regmap);
690 	}
691 
692 	priv->phy_ref_clk = devm_clk_get(&pdev->dev, "phy_ref");
693 	if (IS_ERR(priv->phy_ref_clk)) {
694 		dev_err(dev, "No phy_ref clock found\n");
695 		return PTR_ERR(priv->phy_ref_clk);
696 	}
697 	dev_dbg(dev, "phy_ref clock rate: %lu\n",
698 		clk_get_rate(priv->phy_ref_clk));
699 
700 	if (priv->devdata->is_combo) {
701 		priv->lvds_regmap =
702 			syscon_regmap_lookup_by_phandle(np, "fsl,syscon");
703 		if (IS_ERR(priv->lvds_regmap)) {
704 			ret = PTR_ERR(priv->lvds_regmap);
705 			dev_err_probe(dev, ret, "Failed to get LVDS regmap\n");
706 			return ret;
707 		}
708 
709 		priv->id = of_alias_get_id(np, "mipi-dphy");
710 		if (priv->id < 0) {
711 			dev_err(dev, "Failed to get phy node alias id: %d\n",
712 				priv->id);
713 			return priv->id;
714 		}
715 
716 		ret = imx_scu_get_handle(&priv->ipc_handle);
717 		if (ret) {
718 			dev_err_probe(dev, ret,
719 				      "Failed to get SCU ipc handle\n");
720 			return ret;
721 		}
722 	}
723 
724 	dev_set_drvdata(dev, priv);
725 
726 	phy = devm_phy_create(dev, np, &mixel_dphy_phy_ops);
727 	if (IS_ERR(phy)) {
728 		dev_err(dev, "Failed to create phy %ld\n", PTR_ERR(phy));
729 		return PTR_ERR(phy);
730 	}
731 	phy_set_drvdata(phy, priv);
732 
733 	phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);
734 
735 	return PTR_ERR_OR_ZERO(phy_provider);
736 }
737 
738 static struct platform_driver mixel_dphy_driver = {
739 	.probe	= mixel_dphy_probe,
740 	.driver = {
741 		.name = "mixel-mipi-dphy",
742 		.of_match_table	= mixel_dphy_of_match,
743 	}
744 };
745 module_platform_driver(mixel_dphy_driver);
746 
747 MODULE_AUTHOR("NXP Semiconductor");
748 MODULE_DESCRIPTION("Mixel MIPI-DSI PHY driver");
749 MODULE_LICENSE("GPL");
750