1 // SPDX-License-Identifier: GPL-2.0+
2 /* Copyright (c) 2021-2022 NXP. */
4 #include <linux/module.h>
6 #include <linux/phy/phy.h>
7 #include <linux/platform_device.h>
8 #include <linux/workqueue.h>
10 #define LYNX_28G_NUM_LANE 8
11 #define LYNX_28G_NUM_PLL 2
13 /* General registers per SerDes block */
14 #define LYNX_28G_PCC8 0x10a0
15 #define LYNX_28G_PCC8_SGMII 0x1
16 #define LYNX_28G_PCC8_SGMII_DIS 0x0
18 #define LYNX_28G_PCCC 0x10b0
19 #define LYNX_28G_PCCC_10GBASER 0x9
20 #define LYNX_28G_PCCC_USXGMII 0x1
21 #define LYNX_28G_PCCC_SXGMII_DIS 0x0
23 #define LYNX_28G_LNa_PCC_OFFSET(lane) (4 * (LYNX_28G_NUM_LANE - (lane->id) - 1))
25 /* Per PLL registers */
26 #define LYNX_28G_PLLnRSTCTL(pll) (0x400 + (pll) * 0x100 + 0x0)
27 #define LYNX_28G_PLLnRSTCTL_DIS(rstctl) (((rstctl) & BIT(24)) >> 24)
28 #define LYNX_28G_PLLnRSTCTL_LOCK(rstctl) (((rstctl) & BIT(23)) >> 23)
30 #define LYNX_28G_PLLnCR0(pll) (0x400 + (pll) * 0x100 + 0x4)
31 #define LYNX_28G_PLLnCR0_REFCLK_SEL(cr0) (((cr0) & GENMASK(20, 16)))
32 #define LYNX_28G_PLLnCR0_REFCLK_SEL_100MHZ 0x0
33 #define LYNX_28G_PLLnCR0_REFCLK_SEL_125MHZ 0x10000
34 #define LYNX_28G_PLLnCR0_REFCLK_SEL_156MHZ 0x20000
35 #define LYNX_28G_PLLnCR0_REFCLK_SEL_150MHZ 0x30000
36 #define LYNX_28G_PLLnCR0_REFCLK_SEL_161MHZ 0x40000
38 #define LYNX_28G_PLLnCR1(pll) (0x400 + (pll) * 0x100 + 0x8)
39 #define LYNX_28G_PLLnCR1_FRATE_SEL(cr1) (((cr1) & GENMASK(28, 24)))
40 #define LYNX_28G_PLLnCR1_FRATE_5G_10GVCO 0x0
41 #define LYNX_28G_PLLnCR1_FRATE_5G_25GVCO 0x10000000
42 #define LYNX_28G_PLLnCR1_FRATE_10G_20GVCO 0x6000000
44 /* Per SerDes lane registers */
45 /* Lane a General Control Register */
46 #define LYNX_28G_LNaGCR0(lane) (0x800 + (lane) * 0x100 + 0x0)
47 #define LYNX_28G_LNaGCR0_PROTO_SEL_MSK GENMASK(7, 3)
48 #define LYNX_28G_LNaGCR0_PROTO_SEL_SGMII 0x8
49 #define LYNX_28G_LNaGCR0_PROTO_SEL_XFI 0x50
50 #define LYNX_28G_LNaGCR0_IF_WIDTH_MSK GENMASK(2, 0)
51 #define LYNX_28G_LNaGCR0_IF_WIDTH_10_BIT 0x0
52 #define LYNX_28G_LNaGCR0_IF_WIDTH_20_BIT 0x2
54 /* Lane a Tx Reset Control Register */
55 #define LYNX_28G_LNaTRSTCTL(lane) (0x800 + (lane) * 0x100 + 0x20)
56 #define LYNX_28G_LNaTRSTCTL_HLT_REQ BIT(27)
57 #define LYNX_28G_LNaTRSTCTL_RST_DONE BIT(30)
58 #define LYNX_28G_LNaTRSTCTL_RST_REQ BIT(31)
60 /* Lane a Tx General Control Register */
61 #define LYNX_28G_LNaTGCR0(lane) (0x800 + (lane) * 0x100 + 0x24)
62 #define LYNX_28G_LNaTGCR0_USE_PLLF 0x0
63 #define LYNX_28G_LNaTGCR0_USE_PLLS BIT(28)
64 #define LYNX_28G_LNaTGCR0_USE_PLL_MSK BIT(28)
65 #define LYNX_28G_LNaTGCR0_N_RATE_FULL 0x0
66 #define LYNX_28G_LNaTGCR0_N_RATE_HALF 0x1000000
67 #define LYNX_28G_LNaTGCR0_N_RATE_QUARTER 0x2000000
68 #define LYNX_28G_LNaTGCR0_N_RATE_MSK GENMASK(26, 24)
70 #define LYNX_28G_LNaTECR0(lane) (0x800 + (lane) * 0x100 + 0x30)
72 /* Lane a Rx Reset Control Register */
73 #define LYNX_28G_LNaRRSTCTL(lane) (0x800 + (lane) * 0x100 + 0x40)
74 #define LYNX_28G_LNaRRSTCTL_HLT_REQ BIT(27)
75 #define LYNX_28G_LNaRRSTCTL_RST_DONE BIT(30)
76 #define LYNX_28G_LNaRRSTCTL_RST_REQ BIT(31)
77 #define LYNX_28G_LNaRRSTCTL_CDR_LOCK BIT(12)
79 /* Lane a Rx General Control Register */
80 #define LYNX_28G_LNaRGCR0(lane) (0x800 + (lane) * 0x100 + 0x44)
81 #define LYNX_28G_LNaRGCR0_USE_PLLF 0x0
82 #define LYNX_28G_LNaRGCR0_USE_PLLS BIT(28)
83 #define LYNX_28G_LNaRGCR0_USE_PLL_MSK BIT(28)
84 #define LYNX_28G_LNaRGCR0_N_RATE_MSK GENMASK(26, 24)
85 #define LYNX_28G_LNaRGCR0_N_RATE_FULL 0x0
86 #define LYNX_28G_LNaRGCR0_N_RATE_HALF 0x1000000
87 #define LYNX_28G_LNaRGCR0_N_RATE_QUARTER 0x2000000
88 #define LYNX_28G_LNaRGCR0_N_RATE_MSK GENMASK(26, 24)
90 #define LYNX_28G_LNaRGCR1(lane) (0x800 + (lane) * 0x100 + 0x48)
92 #define LYNX_28G_LNaRECR0(lane) (0x800 + (lane) * 0x100 + 0x50)
93 #define LYNX_28G_LNaRECR1(lane) (0x800 + (lane) * 0x100 + 0x54)
94 #define LYNX_28G_LNaRECR2(lane) (0x800 + (lane) * 0x100 + 0x58)
96 #define LYNX_28G_LNaRSCCR0(lane) (0x800 + (lane) * 0x100 + 0x74)
98 #define LYNX_28G_LNaPSS(lane) (0x1000 + (lane) * 0x4)
99 #define LYNX_28G_LNaPSS_TYPE(pss) (((pss) & GENMASK(30, 24)) >> 24)
100 #define LYNX_28G_LNaPSS_TYPE_SGMII 0x4
101 #define LYNX_28G_LNaPSS_TYPE_XFI 0x28
103 #define LYNX_28G_SGMIIaCR1(lane) (0x1804 + (lane) * 0x10)
104 #define LYNX_28G_SGMIIaCR1_SGPCS_EN BIT(11)
105 #define LYNX_28G_SGMIIaCR1_SGPCS_DIS 0x0
106 #define LYNX_28G_SGMIIaCR1_SGPCS_MSK BIT(11)
108 struct lynx_28g_priv;
110 struct lynx_28g_pll {
111 struct lynx_28g_priv *priv;
112 u32 rstctl, cr0, cr1;
114 DECLARE_PHY_INTERFACE_MASK(supported);
117 struct lynx_28g_lane {
118 struct lynx_28g_priv *priv;
123 phy_interface_t interface;
126 struct lynx_28g_priv {
129 struct lynx_28g_pll pll[LYNX_28G_NUM_PLL];
130 struct lynx_28g_lane lane[LYNX_28G_NUM_LANE];
132 struct delayed_work cdr_check;
135 static void lynx_28g_rmw(struct lynx_28g_priv *priv, unsigned long off,
138 void __iomem *reg = priv->base + off;
141 orig = ioread32(reg);
147 #define lynx_28g_lane_rmw(lane, reg, val, mask) \
148 lynx_28g_rmw((lane)->priv, LYNX_28G_##reg(lane->id), \
149 LYNX_28G_##reg##_##val, LYNX_28G_##reg##_##mask)
150 #define lynx_28g_lane_read(lane, reg) \
151 ioread32((lane)->priv->base + LYNX_28G_##reg((lane)->id))
152 #define lynx_28g_pll_read(pll, reg) \
153 ioread32((pll)->priv->base + LYNX_28G_##reg((pll)->id))
155 static bool lynx_28g_supports_interface(struct lynx_28g_priv *priv, int intf)
159 for (i = 0; i < LYNX_28G_NUM_PLL; i++) {
160 if (LYNX_28G_PLLnRSTCTL_DIS(priv->pll[i].rstctl))
163 if (test_bit(intf, priv->pll[i].supported))
170 static struct lynx_28g_pll *lynx_28g_pll_get(struct lynx_28g_priv *priv,
171 phy_interface_t intf)
173 struct lynx_28g_pll *pll;
176 for (i = 0; i < LYNX_28G_NUM_PLL; i++) {
179 if (LYNX_28G_PLLnRSTCTL_DIS(pll->rstctl))
182 if (test_bit(intf, pll->supported))
189 static void lynx_28g_lane_set_nrate(struct lynx_28g_lane *lane,
190 struct lynx_28g_pll *pll,
191 phy_interface_t intf)
193 switch (LYNX_28G_PLLnCR1_FRATE_SEL(pll->cr1)) {
194 case LYNX_28G_PLLnCR1_FRATE_5G_10GVCO:
195 case LYNX_28G_PLLnCR1_FRATE_5G_25GVCO:
197 case PHY_INTERFACE_MODE_SGMII:
198 case PHY_INTERFACE_MODE_1000BASEX:
199 lynx_28g_lane_rmw(lane, LNaTGCR0, N_RATE_QUARTER, N_RATE_MSK);
200 lynx_28g_lane_rmw(lane, LNaRGCR0, N_RATE_QUARTER, N_RATE_MSK);
206 case LYNX_28G_PLLnCR1_FRATE_10G_20GVCO:
208 case PHY_INTERFACE_MODE_10GBASER:
209 case PHY_INTERFACE_MODE_USXGMII:
210 lynx_28g_lane_rmw(lane, LNaTGCR0, N_RATE_FULL, N_RATE_MSK);
211 lynx_28g_lane_rmw(lane, LNaRGCR0, N_RATE_FULL, N_RATE_MSK);
222 static void lynx_28g_lane_set_pll(struct lynx_28g_lane *lane,
223 struct lynx_28g_pll *pll)
226 lynx_28g_lane_rmw(lane, LNaTGCR0, USE_PLLF, USE_PLL_MSK);
227 lynx_28g_lane_rmw(lane, LNaRGCR0, USE_PLLF, USE_PLL_MSK);
229 lynx_28g_lane_rmw(lane, LNaTGCR0, USE_PLLS, USE_PLL_MSK);
230 lynx_28g_lane_rmw(lane, LNaRGCR0, USE_PLLS, USE_PLL_MSK);
234 static void lynx_28g_cleanup_lane(struct lynx_28g_lane *lane)
236 u32 lane_offset = LYNX_28G_LNa_PCC_OFFSET(lane);
237 struct lynx_28g_priv *priv = lane->priv;
239 /* Cleanup the protocol configuration registers of the current protocol */
240 switch (lane->interface) {
241 case PHY_INTERFACE_MODE_10GBASER:
242 lynx_28g_rmw(priv, LYNX_28G_PCCC,
243 LYNX_28G_PCCC_SXGMII_DIS << lane_offset,
244 GENMASK(3, 0) << lane_offset);
246 case PHY_INTERFACE_MODE_SGMII:
247 case PHY_INTERFACE_MODE_1000BASEX:
248 lynx_28g_rmw(priv, LYNX_28G_PCC8,
249 LYNX_28G_PCC8_SGMII_DIS << lane_offset,
250 GENMASK(3, 0) << lane_offset);
257 static void lynx_28g_lane_set_sgmii(struct lynx_28g_lane *lane)
259 u32 lane_offset = LYNX_28G_LNa_PCC_OFFSET(lane);
260 struct lynx_28g_priv *priv = lane->priv;
261 struct lynx_28g_pll *pll;
263 lynx_28g_cleanup_lane(lane);
265 /* Setup the lane to run in SGMII */
266 lynx_28g_rmw(priv, LYNX_28G_PCC8,
267 LYNX_28G_PCC8_SGMII << lane_offset,
268 GENMASK(3, 0) << lane_offset);
270 /* Setup the protocol select and SerDes parallel interface width */
271 lynx_28g_lane_rmw(lane, LNaGCR0, PROTO_SEL_SGMII, PROTO_SEL_MSK);
272 lynx_28g_lane_rmw(lane, LNaGCR0, IF_WIDTH_10_BIT, IF_WIDTH_MSK);
274 /* Switch to the PLL that works with this interface type */
275 pll = lynx_28g_pll_get(priv, PHY_INTERFACE_MODE_SGMII);
276 lynx_28g_lane_set_pll(lane, pll);
278 /* Choose the portion of clock net to be used on this lane */
279 lynx_28g_lane_set_nrate(lane, pll, PHY_INTERFACE_MODE_SGMII);
281 /* Enable the SGMII PCS */
282 lynx_28g_lane_rmw(lane, SGMIIaCR1, SGPCS_EN, SGPCS_MSK);
284 /* Configure the appropriate equalization parameters for the protocol */
285 iowrite32(0x00808006, priv->base + LYNX_28G_LNaTECR0(lane->id));
286 iowrite32(0x04310000, priv->base + LYNX_28G_LNaRGCR1(lane->id));
287 iowrite32(0x9f800000, priv->base + LYNX_28G_LNaRECR0(lane->id));
288 iowrite32(0x001f0000, priv->base + LYNX_28G_LNaRECR1(lane->id));
289 iowrite32(0x00000000, priv->base + LYNX_28G_LNaRECR2(lane->id));
290 iowrite32(0x00000000, priv->base + LYNX_28G_LNaRSCCR0(lane->id));
293 static void lynx_28g_lane_set_10gbaser(struct lynx_28g_lane *lane)
295 u32 lane_offset = LYNX_28G_LNa_PCC_OFFSET(lane);
296 struct lynx_28g_priv *priv = lane->priv;
297 struct lynx_28g_pll *pll;
299 lynx_28g_cleanup_lane(lane);
301 /* Enable the SXGMII lane */
302 lynx_28g_rmw(priv, LYNX_28G_PCCC,
303 LYNX_28G_PCCC_10GBASER << lane_offset,
304 GENMASK(3, 0) << lane_offset);
306 /* Setup the protocol select and SerDes parallel interface width */
307 lynx_28g_lane_rmw(lane, LNaGCR0, PROTO_SEL_XFI, PROTO_SEL_MSK);
308 lynx_28g_lane_rmw(lane, LNaGCR0, IF_WIDTH_20_BIT, IF_WIDTH_MSK);
310 /* Switch to the PLL that works with this interface type */
311 pll = lynx_28g_pll_get(priv, PHY_INTERFACE_MODE_10GBASER);
312 lynx_28g_lane_set_pll(lane, pll);
314 /* Choose the portion of clock net to be used on this lane */
315 lynx_28g_lane_set_nrate(lane, pll, PHY_INTERFACE_MODE_10GBASER);
317 /* Disable the SGMII PCS */
318 lynx_28g_lane_rmw(lane, SGMIIaCR1, SGPCS_DIS, SGPCS_MSK);
320 /* Configure the appropriate equalization parameters for the protocol */
321 iowrite32(0x10808307, priv->base + LYNX_28G_LNaTECR0(lane->id));
322 iowrite32(0x10000000, priv->base + LYNX_28G_LNaRGCR1(lane->id));
323 iowrite32(0x00000000, priv->base + LYNX_28G_LNaRECR0(lane->id));
324 iowrite32(0x001f0000, priv->base + LYNX_28G_LNaRECR1(lane->id));
325 iowrite32(0x81000020, priv->base + LYNX_28G_LNaRECR2(lane->id));
326 iowrite32(0x00002000, priv->base + LYNX_28G_LNaRSCCR0(lane->id));
329 static int lynx_28g_power_off(struct phy *phy)
331 struct lynx_28g_lane *lane = phy_get_drvdata(phy);
332 u32 trstctl, rrstctl;
334 if (!lane->powered_up)
337 /* Issue a halt request */
338 lynx_28g_lane_rmw(lane, LNaTRSTCTL, HLT_REQ, HLT_REQ);
339 lynx_28g_lane_rmw(lane, LNaRRSTCTL, HLT_REQ, HLT_REQ);
341 /* Wait until the halting process is complete */
343 trstctl = lynx_28g_lane_read(lane, LNaTRSTCTL);
344 rrstctl = lynx_28g_lane_read(lane, LNaRRSTCTL);
345 } while ((trstctl & LYNX_28G_LNaTRSTCTL_HLT_REQ) ||
346 (rrstctl & LYNX_28G_LNaRRSTCTL_HLT_REQ));
348 lane->powered_up = false;
353 static int lynx_28g_power_on(struct phy *phy)
355 struct lynx_28g_lane *lane = phy_get_drvdata(phy);
356 u32 trstctl, rrstctl;
358 if (lane->powered_up)
361 /* Issue a reset request on the lane */
362 lynx_28g_lane_rmw(lane, LNaTRSTCTL, RST_REQ, RST_REQ);
363 lynx_28g_lane_rmw(lane, LNaRRSTCTL, RST_REQ, RST_REQ);
365 /* Wait until the reset sequence is completed */
367 trstctl = lynx_28g_lane_read(lane, LNaTRSTCTL);
368 rrstctl = lynx_28g_lane_read(lane, LNaRRSTCTL);
369 } while (!(trstctl & LYNX_28G_LNaTRSTCTL_RST_DONE) ||
370 !(rrstctl & LYNX_28G_LNaRRSTCTL_RST_DONE));
372 lane->powered_up = true;
377 static int lynx_28g_set_mode(struct phy *phy, enum phy_mode mode, int submode)
379 struct lynx_28g_lane *lane = phy_get_drvdata(phy);
380 struct lynx_28g_priv *priv = lane->priv;
381 int powered_up = lane->powered_up;
384 if (mode != PHY_MODE_ETHERNET)
387 if (lane->interface == PHY_INTERFACE_MODE_NA)
390 if (!lynx_28g_supports_interface(priv, submode))
393 /* If the lane is powered up, put the lane into the halt state while
394 * the reconfiguration is being done.
397 lynx_28g_power_off(phy);
400 case PHY_INTERFACE_MODE_SGMII:
401 case PHY_INTERFACE_MODE_1000BASEX:
402 lynx_28g_lane_set_sgmii(lane);
404 case PHY_INTERFACE_MODE_10GBASER:
405 lynx_28g_lane_set_10gbaser(lane);
412 lane->interface = submode;
415 /* Power up the lane if necessary */
417 lynx_28g_power_on(phy);
422 static int lynx_28g_validate(struct phy *phy, enum phy_mode mode, int submode,
423 union phy_configure_opts *opts __always_unused)
425 struct lynx_28g_lane *lane = phy_get_drvdata(phy);
426 struct lynx_28g_priv *priv = lane->priv;
428 if (mode != PHY_MODE_ETHERNET)
431 if (!lynx_28g_supports_interface(priv, submode))
437 static int lynx_28g_init(struct phy *phy)
439 struct lynx_28g_lane *lane = phy_get_drvdata(phy);
441 /* Mark the fact that the lane was init */
444 /* SerDes lanes are powered on at boot time. Any lane that is managed
445 * by this driver will get powered down at init time aka at dpaa2-eth
448 lane->powered_up = true;
449 lynx_28g_power_off(phy);
454 static const struct phy_ops lynx_28g_ops = {
455 .init = lynx_28g_init,
456 .power_on = lynx_28g_power_on,
457 .power_off = lynx_28g_power_off,
458 .set_mode = lynx_28g_set_mode,
459 .validate = lynx_28g_validate,
460 .owner = THIS_MODULE,
463 static void lynx_28g_pll_read_configuration(struct lynx_28g_priv *priv)
465 struct lynx_28g_pll *pll;
468 for (i = 0; i < LYNX_28G_NUM_PLL; i++) {
473 pll->rstctl = lynx_28g_pll_read(pll, PLLnRSTCTL);
474 pll->cr0 = lynx_28g_pll_read(pll, PLLnCR0);
475 pll->cr1 = lynx_28g_pll_read(pll, PLLnCR1);
477 if (LYNX_28G_PLLnRSTCTL_DIS(pll->rstctl))
480 switch (LYNX_28G_PLLnCR1_FRATE_SEL(pll->cr1)) {
481 case LYNX_28G_PLLnCR1_FRATE_5G_10GVCO:
482 case LYNX_28G_PLLnCR1_FRATE_5G_25GVCO:
484 __set_bit(PHY_INTERFACE_MODE_1000BASEX, pll->supported);
485 __set_bit(PHY_INTERFACE_MODE_SGMII, pll->supported);
487 case LYNX_28G_PLLnCR1_FRATE_10G_20GVCO:
488 /* 10.3125GHz clock net */
489 __set_bit(PHY_INTERFACE_MODE_10GBASER, pll->supported);
492 /* 6GHz, 12.890625GHz, 8GHz */
498 #define work_to_lynx(w) container_of((w), struct lynx_28g_priv, cdr_check.work)
500 static void lynx_28g_cdr_lock_check(struct work_struct *work)
502 struct lynx_28g_priv *priv = work_to_lynx(work);
503 struct lynx_28g_lane *lane;
507 for (i = 0; i < LYNX_28G_NUM_LANE; i++) {
508 lane = &priv->lane[i];
513 if (!lane->powered_up)
516 rrstctl = lynx_28g_lane_read(lane, LNaRRSTCTL);
517 if (!(rrstctl & LYNX_28G_LNaRRSTCTL_CDR_LOCK)) {
518 lynx_28g_lane_rmw(lane, LNaRRSTCTL, RST_REQ, RST_REQ);
520 rrstctl = lynx_28g_lane_read(lane, LNaRRSTCTL);
521 } while (!(rrstctl & LYNX_28G_LNaRRSTCTL_RST_DONE));
524 queue_delayed_work(system_power_efficient_wq, &priv->cdr_check,
525 msecs_to_jiffies(1000));
528 static void lynx_28g_lane_read_configuration(struct lynx_28g_lane *lane)
532 pss = lynx_28g_lane_read(lane, LNaPSS);
533 protocol = LYNX_28G_LNaPSS_TYPE(pss);
535 case LYNX_28G_LNaPSS_TYPE_SGMII:
536 lane->interface = PHY_INTERFACE_MODE_SGMII;
538 case LYNX_28G_LNaPSS_TYPE_XFI:
539 lane->interface = PHY_INTERFACE_MODE_10GBASER;
542 lane->interface = PHY_INTERFACE_MODE_NA;
546 static struct phy *lynx_28g_xlate(struct device *dev,
547 struct of_phandle_args *args)
549 struct lynx_28g_priv *priv = dev_get_drvdata(dev);
550 int idx = args->args[0];
552 if (WARN_ON(idx >= LYNX_28G_NUM_LANE))
553 return ERR_PTR(-EINVAL);
555 return priv->lane[idx].phy;
558 static int lynx_28g_probe(struct platform_device *pdev)
560 struct device *dev = &pdev->dev;
561 struct phy_provider *provider;
562 struct lynx_28g_priv *priv;
565 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
568 priv->dev = &pdev->dev;
570 priv->base = devm_platform_ioremap_resource(pdev, 0);
571 if (IS_ERR(priv->base))
572 return PTR_ERR(priv->base);
574 lynx_28g_pll_read_configuration(priv);
576 for (i = 0; i < LYNX_28G_NUM_LANE; i++) {
577 struct lynx_28g_lane *lane = &priv->lane[i];
580 memset(lane, 0, sizeof(*lane));
582 phy = devm_phy_create(&pdev->dev, NULL, &lynx_28g_ops);
589 phy_set_drvdata(phy, lane);
590 lynx_28g_lane_read_configuration(lane);
593 dev_set_drvdata(dev, priv);
595 INIT_DELAYED_WORK(&priv->cdr_check, lynx_28g_cdr_lock_check);
597 queue_delayed_work(system_power_efficient_wq, &priv->cdr_check,
598 msecs_to_jiffies(1000));
600 dev_set_drvdata(&pdev->dev, priv);
601 provider = devm_of_phy_provider_register(&pdev->dev, lynx_28g_xlate);
603 return PTR_ERR_OR_ZERO(provider);
606 static const struct of_device_id lynx_28g_of_match_table[] = {
607 { .compatible = "fsl,lynx-28g" },
610 MODULE_DEVICE_TABLE(of, lynx_28g_of_match_table);
612 static struct platform_driver lynx_28g_driver = {
613 .probe = lynx_28g_probe,
616 .of_match_table = lynx_28g_of_match_table,
619 module_platform_driver(lynx_28g_driver);
621 MODULE_AUTHOR("Ioana Ciornei <ioana.ciornei@nxp.com>");
622 MODULE_DESCRIPTION("Lynx 28G SerDes PHY driver for Layerscape SoCs");
623 MODULE_LICENSE("GPL v2");