1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /* Copyright 2020 NXP
3 * Lynx PCS MDIO helpers
4 */
5
6 #include <linux/mdio.h>
7 #include <linux/phylink.h>
8 #include <linux/pcs-lynx.h>
9 #include <linux/property.h>
10
11 #define SGMII_CLOCK_PERIOD_NS 8 /* PCS is clocked at 125 MHz */
12 #define LINK_TIMER_VAL(ns) ((u32)((ns) / SGMII_CLOCK_PERIOD_NS))
13
14 #define LINK_TIMER_LO 0x12
15 #define LINK_TIMER_HI 0x13
16 #define IF_MODE 0x14
17 #define IF_MODE_SGMII_EN BIT(0)
18 #define IF_MODE_USE_SGMII_AN BIT(1)
19 #define IF_MODE_SPEED(x) (((x) << 2) & GENMASK(3, 2))
20 #define IF_MODE_SPEED_MSK GENMASK(3, 2)
21 #define IF_MODE_HALF_DUPLEX BIT(4)
22
23 struct lynx_pcs {
24 struct phylink_pcs pcs;
25 struct mdio_device *mdio;
26 };
27
28 enum sgmii_speed {
29 SGMII_SPEED_10 = 0,
30 SGMII_SPEED_100 = 1,
31 SGMII_SPEED_1000 = 2,
32 SGMII_SPEED_2500 = 2,
33 };
34
35 #define phylink_pcs_to_lynx(pl_pcs) container_of((pl_pcs), struct lynx_pcs, pcs)
36 #define lynx_to_phylink_pcs(lynx) (&(lynx)->pcs)
37
lynx_pcs_inband_caps(struct phylink_pcs * pcs,phy_interface_t interface)38 static unsigned int lynx_pcs_inband_caps(struct phylink_pcs *pcs,
39 phy_interface_t interface)
40 {
41 switch (interface) {
42 case PHY_INTERFACE_MODE_1000BASEX:
43 case PHY_INTERFACE_MODE_2500BASEX:
44 case PHY_INTERFACE_MODE_SGMII:
45 case PHY_INTERFACE_MODE_QSGMII:
46 return LINK_INBAND_DISABLE | LINK_INBAND_ENABLE;
47
48 case PHY_INTERFACE_MODE_10GBASER:
49 return LINK_INBAND_DISABLE;
50
51 case PHY_INTERFACE_MODE_USXGMII:
52 case PHY_INTERFACE_MODE_10G_QXGMII:
53 return LINK_INBAND_ENABLE;
54
55 default:
56 return 0;
57 }
58 }
59
lynx_pcs_get_state_usxgmii(struct mdio_device * pcs,struct phylink_link_state * state)60 static void lynx_pcs_get_state_usxgmii(struct mdio_device *pcs,
61 struct phylink_link_state *state)
62 {
63 struct mii_bus *bus = pcs->bus;
64 int addr = pcs->addr;
65 int status, lpa;
66
67 status = mdiobus_c45_read(bus, addr, MDIO_MMD_VEND2, MII_BMSR);
68 if (status < 0)
69 return;
70
71 state->link = !!(status & MDIO_STAT1_LSTATUS);
72 state->an_complete = !!(status & MDIO_AN_STAT1_COMPLETE);
73 if (!state->link || !state->an_complete)
74 return;
75
76 lpa = mdiobus_c45_read(bus, addr, MDIO_MMD_VEND2, MII_LPA);
77 if (lpa < 0)
78 return;
79
80 phylink_decode_usxgmii_word(state, lpa);
81 }
82
lynx_pcs_get_state(struct phylink_pcs * pcs,unsigned int neg_mode,struct phylink_link_state * state)83 static void lynx_pcs_get_state(struct phylink_pcs *pcs, unsigned int neg_mode,
84 struct phylink_link_state *state)
85 {
86 struct lynx_pcs *lynx = phylink_pcs_to_lynx(pcs);
87
88 switch (state->interface) {
89 case PHY_INTERFACE_MODE_1000BASEX:
90 case PHY_INTERFACE_MODE_2500BASEX:
91 case PHY_INTERFACE_MODE_SGMII:
92 case PHY_INTERFACE_MODE_QSGMII:
93 phylink_mii_c22_pcs_get_state(lynx->mdio, neg_mode, state);
94 break;
95 case PHY_INTERFACE_MODE_USXGMII:
96 case PHY_INTERFACE_MODE_10G_QXGMII:
97 lynx_pcs_get_state_usxgmii(lynx->mdio, state);
98 break;
99 case PHY_INTERFACE_MODE_10GBASER:
100 phylink_mii_c45_pcs_get_state(lynx->mdio, state);
101 break;
102 default:
103 break;
104 }
105
106 dev_dbg(&lynx->mdio->dev,
107 "mode=%s/%s/%s link=%u an_complete=%u\n",
108 phy_modes(state->interface),
109 phy_speed_to_str(state->speed),
110 phy_duplex_to_str(state->duplex),
111 state->link, state->an_complete);
112 }
113
lynx_pcs_config_giga(struct mdio_device * pcs,phy_interface_t interface,const unsigned long * advertising,unsigned int neg_mode)114 static int lynx_pcs_config_giga(struct mdio_device *pcs,
115 phy_interface_t interface,
116 const unsigned long *advertising,
117 unsigned int neg_mode)
118 {
119 int link_timer_ns;
120 u32 link_timer;
121 u16 if_mode;
122 int err;
123
124 link_timer_ns = phylink_get_link_timer_ns(interface);
125 if (link_timer_ns > 0) {
126 link_timer = LINK_TIMER_VAL(link_timer_ns);
127
128 mdiodev_write(pcs, LINK_TIMER_LO, link_timer & 0xffff);
129 mdiodev_write(pcs, LINK_TIMER_HI, link_timer >> 16);
130 }
131
132 if (interface == PHY_INTERFACE_MODE_1000BASEX ||
133 interface == PHY_INTERFACE_MODE_2500BASEX) {
134 if_mode = 0;
135 } else {
136 /* SGMII and QSGMII */
137 if_mode = IF_MODE_SGMII_EN;
138 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED)
139 if_mode |= IF_MODE_USE_SGMII_AN;
140 }
141
142 err = mdiodev_modify(pcs, IF_MODE,
143 IF_MODE_SGMII_EN | IF_MODE_USE_SGMII_AN,
144 if_mode);
145 if (err)
146 return err;
147
148 return phylink_mii_c22_pcs_config(pcs, interface, advertising,
149 neg_mode);
150 }
151
lynx_pcs_config_usxgmii(struct mdio_device * pcs,phy_interface_t interface,const unsigned long * advertising,unsigned int neg_mode)152 static int lynx_pcs_config_usxgmii(struct mdio_device *pcs,
153 phy_interface_t interface,
154 const unsigned long *advertising,
155 unsigned int neg_mode)
156 {
157 struct mii_bus *bus = pcs->bus;
158 int addr = pcs->addr;
159
160 if (neg_mode != PHYLINK_PCS_NEG_INBAND_ENABLED) {
161 dev_err(&pcs->dev, "%s only supports in-band AN for now\n",
162 phy_modes(interface));
163 return -EOPNOTSUPP;
164 }
165
166 /* Configure device ability for the USXGMII Replicator */
167 return mdiobus_c45_write(bus, addr, MDIO_MMD_VEND2, MII_ADVERTISE,
168 MDIO_USXGMII_10G | MDIO_USXGMII_LINK |
169 MDIO_USXGMII_FULL_DUPLEX |
170 ADVERTISE_SGMII | ADVERTISE_LPACK);
171 }
172
lynx_pcs_config(struct phylink_pcs * pcs,unsigned int neg_mode,phy_interface_t ifmode,const unsigned long * advertising,bool permit)173 static int lynx_pcs_config(struct phylink_pcs *pcs, unsigned int neg_mode,
174 phy_interface_t ifmode,
175 const unsigned long *advertising, bool permit)
176 {
177 struct lynx_pcs *lynx = phylink_pcs_to_lynx(pcs);
178
179 switch (ifmode) {
180 case PHY_INTERFACE_MODE_1000BASEX:
181 case PHY_INTERFACE_MODE_SGMII:
182 case PHY_INTERFACE_MODE_QSGMII:
183 case PHY_INTERFACE_MODE_2500BASEX:
184 return lynx_pcs_config_giga(lynx->mdio, ifmode, advertising,
185 neg_mode);
186 case PHY_INTERFACE_MODE_USXGMII:
187 case PHY_INTERFACE_MODE_10G_QXGMII:
188 return lynx_pcs_config_usxgmii(lynx->mdio, ifmode, advertising,
189 neg_mode);
190 case PHY_INTERFACE_MODE_10GBASER:
191 /* Nothing to do here for 10GBASER */
192 break;
193 default:
194 return -EOPNOTSUPP;
195 }
196
197 return 0;
198 }
199
lynx_pcs_an_restart(struct phylink_pcs * pcs)200 static void lynx_pcs_an_restart(struct phylink_pcs *pcs)
201 {
202 struct lynx_pcs *lynx = phylink_pcs_to_lynx(pcs);
203
204 phylink_mii_c22_pcs_an_restart(lynx->mdio);
205 }
206
lynx_pcs_link_up_sgmii(struct mdio_device * pcs,unsigned int neg_mode,int speed,int duplex)207 static void lynx_pcs_link_up_sgmii(struct mdio_device *pcs,
208 unsigned int neg_mode,
209 int speed, int duplex)
210 {
211 u16 if_mode = 0, sgmii_speed;
212
213 /* The PCS needs to be configured manually only
214 * when not operating on in-band mode
215 */
216 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED)
217 return;
218
219 if (duplex == DUPLEX_HALF)
220 if_mode |= IF_MODE_HALF_DUPLEX;
221
222 switch (speed) {
223 case SPEED_1000:
224 sgmii_speed = SGMII_SPEED_1000;
225 break;
226 case SPEED_100:
227 sgmii_speed = SGMII_SPEED_100;
228 break;
229 case SPEED_10:
230 sgmii_speed = SGMII_SPEED_10;
231 break;
232 case SPEED_UNKNOWN:
233 /* Silently don't do anything */
234 return;
235 default:
236 dev_err(&pcs->dev, "Invalid PCS speed %d\n", speed);
237 return;
238 }
239 if_mode |= IF_MODE_SPEED(sgmii_speed);
240
241 mdiodev_modify(pcs, IF_MODE,
242 IF_MODE_HALF_DUPLEX | IF_MODE_SPEED_MSK,
243 if_mode);
244 }
245
lynx_pcs_link_up(struct phylink_pcs * pcs,unsigned int neg_mode,phy_interface_t interface,int speed,int duplex)246 static void lynx_pcs_link_up(struct phylink_pcs *pcs, unsigned int neg_mode,
247 phy_interface_t interface,
248 int speed, int duplex)
249 {
250 struct lynx_pcs *lynx = phylink_pcs_to_lynx(pcs);
251
252 switch (interface) {
253 case PHY_INTERFACE_MODE_SGMII:
254 case PHY_INTERFACE_MODE_QSGMII:
255 lynx_pcs_link_up_sgmii(lynx->mdio, neg_mode, speed, duplex);
256 break;
257 case PHY_INTERFACE_MODE_USXGMII:
258 case PHY_INTERFACE_MODE_10G_QXGMII:
259 /* At the moment, only in-band AN is supported for USXGMII
260 * so nothing to do in link_up
261 */
262 break;
263 default:
264 break;
265 }
266 }
267
268 static const struct phylink_pcs_ops lynx_pcs_phylink_ops = {
269 .pcs_inband_caps = lynx_pcs_inband_caps,
270 .pcs_get_state = lynx_pcs_get_state,
271 .pcs_config = lynx_pcs_config,
272 .pcs_an_restart = lynx_pcs_an_restart,
273 .pcs_link_up = lynx_pcs_link_up,
274 };
275
276 static const phy_interface_t lynx_interfaces[] = {
277 PHY_INTERFACE_MODE_SGMII,
278 PHY_INTERFACE_MODE_QSGMII,
279 PHY_INTERFACE_MODE_1000BASEX,
280 PHY_INTERFACE_MODE_2500BASEX,
281 PHY_INTERFACE_MODE_10GBASER,
282 PHY_INTERFACE_MODE_USXGMII,
283 PHY_INTERFACE_MODE_10G_QXGMII,
284 };
285
lynx_pcs_create(struct mdio_device * mdio)286 static struct phylink_pcs *lynx_pcs_create(struct mdio_device *mdio)
287 {
288 struct lynx_pcs *lynx;
289 int i;
290
291 lynx = kzalloc_obj(*lynx);
292 if (!lynx)
293 return ERR_PTR(-ENOMEM);
294
295 mdio_device_get(mdio);
296 lynx->mdio = mdio;
297 lynx->pcs.ops = &lynx_pcs_phylink_ops;
298 lynx->pcs.poll = true;
299
300 for (i = 0; i < ARRAY_SIZE(lynx_interfaces); i++)
301 __set_bit(lynx_interfaces[i], lynx->pcs.supported_interfaces);
302
303 return lynx_to_phylink_pcs(lynx);
304 }
305
lynx_pcs_create_mdiodev(struct mii_bus * bus,int addr)306 struct phylink_pcs *lynx_pcs_create_mdiodev(struct mii_bus *bus, int addr)
307 {
308 struct mdio_device *mdio;
309 struct phylink_pcs *pcs;
310
311 mdio = mdio_device_create(bus, addr);
312 if (IS_ERR(mdio))
313 return ERR_CAST(mdio);
314
315 pcs = lynx_pcs_create(mdio);
316
317 /* lynx_create() has taken a refcount on the mdiodev if it was
318 * successful. If lynx_create() fails, this will free the mdio
319 * device here. In any case, we don't need to hold our reference
320 * anymore, and putting it here will allow mdio_device_put() in
321 * lynx_destroy() to automatically free the mdio device.
322 */
323 mdio_device_put(mdio);
324
325 return pcs;
326 }
327 EXPORT_SYMBOL(lynx_pcs_create_mdiodev);
328
329 /*
330 * lynx_pcs_create_fwnode() creates a lynx PCS instance from the fwnode
331 * device indicated by node.
332 *
333 * Returns:
334 * -ENODEV if the fwnode is marked unavailable
335 * -EPROBE_DEFER if we fail to find the device
336 * -ENOMEM if we fail to allocate memory
337 * pointer to a phylink_pcs on success
338 */
lynx_pcs_create_fwnode(struct fwnode_handle * node)339 struct phylink_pcs *lynx_pcs_create_fwnode(struct fwnode_handle *node)
340 {
341 struct mdio_device *mdio;
342 struct phylink_pcs *pcs;
343
344 if (!fwnode_device_is_available(node))
345 return ERR_PTR(-ENODEV);
346
347 mdio = fwnode_mdio_find_device(node);
348 if (!mdio)
349 return ERR_PTR(-EPROBE_DEFER);
350
351 pcs = lynx_pcs_create(mdio);
352
353 /* lynx_create() has taken a refcount on the mdiodev if it was
354 * successful. If lynx_create() fails, this will free the mdio
355 * device here. In any case, we don't need to hold our reference
356 * anymore, and putting it here will allow mdio_device_put() in
357 * lynx_destroy() to automatically free the mdio device.
358 */
359 mdio_device_put(mdio);
360
361 return pcs;
362 }
363 EXPORT_SYMBOL_GPL(lynx_pcs_create_fwnode);
364
lynx_pcs_destroy(struct phylink_pcs * pcs)365 void lynx_pcs_destroy(struct phylink_pcs *pcs)
366 {
367 struct lynx_pcs *lynx = phylink_pcs_to_lynx(pcs);
368
369 mdio_device_put(lynx->mdio);
370 kfree(lynx);
371 }
372 EXPORT_SYMBOL(lynx_pcs_destroy);
373
374 MODULE_DESCRIPTION("NXP Lynx PCS phylink library");
375 MODULE_LICENSE("Dual BSD/GPL");
376