1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * mdio.c: Generic support for MDIO-compatible transceivers |
4 | * Copyright 2006-2009 Solarflare Communications Inc. |
5 | */ |
6 | |
7 | #include <linux/kernel.h> |
8 | #include <linux/capability.h> |
9 | #include <linux/errno.h> |
10 | #include <linux/ethtool.h> |
11 | #include <linux/mdio.h> |
12 | #include <linux/module.h> |
13 | |
14 | MODULE_DESCRIPTION("Generic support for MDIO-compatible transceivers" ); |
15 | MODULE_AUTHOR("Copyright 2006-2009 Solarflare Communications Inc." ); |
16 | MODULE_LICENSE("GPL" ); |
17 | |
18 | /** |
19 | * mdio45_probe - probe for an MDIO (clause 45) device |
20 | * @mdio: MDIO interface |
21 | * @prtad: Expected PHY address |
22 | * |
23 | * This sets @prtad and @mmds in the MDIO interface if successful. |
24 | * Returns 0 on success, negative on error. |
25 | */ |
26 | int mdio45_probe(struct mdio_if_info *mdio, int prtad) |
27 | { |
28 | int mmd, stat2, devs1, devs2; |
29 | |
30 | /* Assume PHY must have at least one of PMA/PMD, WIS, PCS, PHY |
31 | * XS or DTE XS; give up if none is present. */ |
32 | for (mmd = 1; mmd <= 5; mmd++) { |
33 | /* Is this MMD present? */ |
34 | stat2 = mdio->mdio_read(mdio->dev, prtad, mmd, MDIO_STAT2); |
35 | if (stat2 < 0 || |
36 | (stat2 & MDIO_STAT2_DEVPRST) != MDIO_STAT2_DEVPRST_VAL) |
37 | continue; |
38 | |
39 | /* It should tell us about all the other MMDs */ |
40 | devs1 = mdio->mdio_read(mdio->dev, prtad, mmd, MDIO_DEVS1); |
41 | devs2 = mdio->mdio_read(mdio->dev, prtad, mmd, MDIO_DEVS2); |
42 | if (devs1 < 0 || devs2 < 0) |
43 | continue; |
44 | |
45 | mdio->prtad = prtad; |
46 | mdio->mmds = devs1 | (devs2 << 16); |
47 | return 0; |
48 | } |
49 | |
50 | return -ENODEV; |
51 | } |
52 | EXPORT_SYMBOL(mdio45_probe); |
53 | |
54 | /** |
55 | * mdio_set_flag - set or clear flag in an MDIO register |
56 | * @mdio: MDIO interface |
57 | * @prtad: PHY address |
58 | * @devad: MMD address |
59 | * @addr: Register address |
60 | * @mask: Mask for flag (single bit set) |
61 | * @sense: New value of flag |
62 | * |
63 | * This debounces changes: it does not write the register if the flag |
64 | * already has the proper value. Returns 0 on success, negative on error. |
65 | */ |
66 | int mdio_set_flag(const struct mdio_if_info *mdio, |
67 | int prtad, int devad, u16 addr, int mask, |
68 | bool sense) |
69 | { |
70 | int old_val = mdio->mdio_read(mdio->dev, prtad, devad, addr); |
71 | int new_val; |
72 | |
73 | if (old_val < 0) |
74 | return old_val; |
75 | if (sense) |
76 | new_val = old_val | mask; |
77 | else |
78 | new_val = old_val & ~mask; |
79 | if (old_val == new_val) |
80 | return 0; |
81 | return mdio->mdio_write(mdio->dev, prtad, devad, addr, new_val); |
82 | } |
83 | EXPORT_SYMBOL(mdio_set_flag); |
84 | |
85 | /** |
86 | * mdio45_links_ok - is link status up/OK |
87 | * @mdio: MDIO interface |
88 | * @mmd_mask: Mask for MMDs to check |
89 | * |
90 | * Returns 1 if the PHY reports link status up/OK, 0 otherwise. |
91 | * @mmd_mask is normally @mdio->mmds, but if loopback is enabled |
92 | * the MMDs being bypassed should be excluded from the mask. |
93 | */ |
94 | int mdio45_links_ok(const struct mdio_if_info *mdio, u32 mmd_mask) |
95 | { |
96 | int devad, reg; |
97 | |
98 | if (!mmd_mask) { |
99 | /* Use absence of XGMII faults in lieu of link state */ |
100 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, |
101 | MDIO_MMD_PHYXS, MDIO_STAT2); |
102 | return reg >= 0 && !(reg & MDIO_STAT2_RXFAULT); |
103 | } |
104 | |
105 | for (devad = 0; mmd_mask; devad++) { |
106 | if (mmd_mask & (1 << devad)) { |
107 | mmd_mask &= ~(1 << devad); |
108 | |
109 | /* Reset the latched status and fault flags */ |
110 | mdio->mdio_read(mdio->dev, mdio->prtad, |
111 | devad, MDIO_STAT1); |
112 | if (devad == MDIO_MMD_PMAPMD || devad == MDIO_MMD_PCS || |
113 | devad == MDIO_MMD_PHYXS || devad == MDIO_MMD_DTEXS) |
114 | mdio->mdio_read(mdio->dev, mdio->prtad, |
115 | devad, MDIO_STAT2); |
116 | |
117 | /* Check the current status and fault flags */ |
118 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, |
119 | devad, MDIO_STAT1); |
120 | if (reg < 0 || |
121 | (reg & (MDIO_STAT1_FAULT | MDIO_STAT1_LSTATUS)) != |
122 | MDIO_STAT1_LSTATUS) |
123 | return false; |
124 | } |
125 | } |
126 | |
127 | return true; |
128 | } |
129 | EXPORT_SYMBOL(mdio45_links_ok); |
130 | |
131 | /** |
132 | * mdio45_nway_restart - restart auto-negotiation for this interface |
133 | * @mdio: MDIO interface |
134 | * |
135 | * Returns 0 on success, negative on error. |
136 | */ |
137 | int mdio45_nway_restart(const struct mdio_if_info *mdio) |
138 | { |
139 | if (!(mdio->mmds & MDIO_DEVS_AN)) |
140 | return -EOPNOTSUPP; |
141 | |
142 | mdio_set_flag(mdio, mdio->prtad, MDIO_MMD_AN, MDIO_CTRL1, |
143 | MDIO_AN_CTRL1_RESTART, true); |
144 | return 0; |
145 | } |
146 | EXPORT_SYMBOL(mdio45_nway_restart); |
147 | |
148 | static u32 mdio45_get_an(const struct mdio_if_info *mdio, u16 addr) |
149 | { |
150 | u32 result = 0; |
151 | int reg; |
152 | |
153 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_AN, addr); |
154 | if (reg & ADVERTISE_10HALF) |
155 | result |= ADVERTISED_10baseT_Half; |
156 | if (reg & ADVERTISE_10FULL) |
157 | result |= ADVERTISED_10baseT_Full; |
158 | if (reg & ADVERTISE_100HALF) |
159 | result |= ADVERTISED_100baseT_Half; |
160 | if (reg & ADVERTISE_100FULL) |
161 | result |= ADVERTISED_100baseT_Full; |
162 | if (reg & ADVERTISE_PAUSE_CAP) |
163 | result |= ADVERTISED_Pause; |
164 | if (reg & ADVERTISE_PAUSE_ASYM) |
165 | result |= ADVERTISED_Asym_Pause; |
166 | return result; |
167 | } |
168 | |
169 | /** |
170 | * mdio45_ethtool_gset_npage - get settings for ETHTOOL_GSET |
171 | * @mdio: MDIO interface |
172 | * @ecmd: Ethtool request structure |
173 | * @npage_adv: Modes currently advertised on next pages |
174 | * @npage_lpa: Modes advertised by link partner on next pages |
175 | * |
176 | * The @ecmd parameter is expected to have been cleared before calling |
177 | * mdio45_ethtool_gset_npage(). |
178 | * |
179 | * Since the CSRs for auto-negotiation using next pages are not fully |
180 | * standardised, this function does not attempt to decode them. The |
181 | * caller must pass them in. |
182 | */ |
183 | void mdio45_ethtool_gset_npage(const struct mdio_if_info *mdio, |
184 | struct ethtool_cmd *ecmd, |
185 | u32 npage_adv, u32 npage_lpa) |
186 | { |
187 | int reg; |
188 | u32 speed; |
189 | |
190 | BUILD_BUG_ON(MDIO_SUPPORTS_C22 != ETH_MDIO_SUPPORTS_C22); |
191 | BUILD_BUG_ON(MDIO_SUPPORTS_C45 != ETH_MDIO_SUPPORTS_C45); |
192 | |
193 | ecmd->transceiver = XCVR_INTERNAL; |
194 | ecmd->phy_address = mdio->prtad; |
195 | ecmd->mdio_support = |
196 | mdio->mode_support & (MDIO_SUPPORTS_C45 | MDIO_SUPPORTS_C22); |
197 | |
198 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
199 | MDIO_CTRL2); |
200 | switch (reg & MDIO_PMA_CTRL2_TYPE) { |
201 | case MDIO_PMA_CTRL2_10GBT: |
202 | case MDIO_PMA_CTRL2_1000BT: |
203 | case MDIO_PMA_CTRL2_100BTX: |
204 | case MDIO_PMA_CTRL2_10BT: |
205 | ecmd->port = PORT_TP; |
206 | ecmd->supported = SUPPORTED_TP; |
207 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
208 | MDIO_SPEED); |
209 | if (reg & MDIO_SPEED_10G) |
210 | ecmd->supported |= SUPPORTED_10000baseT_Full; |
211 | if (reg & MDIO_PMA_SPEED_1000) |
212 | ecmd->supported |= (SUPPORTED_1000baseT_Full | |
213 | SUPPORTED_1000baseT_Half); |
214 | if (reg & MDIO_PMA_SPEED_100) |
215 | ecmd->supported |= (SUPPORTED_100baseT_Full | |
216 | SUPPORTED_100baseT_Half); |
217 | if (reg & MDIO_PMA_SPEED_10) |
218 | ecmd->supported |= (SUPPORTED_10baseT_Full | |
219 | SUPPORTED_10baseT_Half); |
220 | ecmd->advertising = ADVERTISED_TP; |
221 | break; |
222 | |
223 | case MDIO_PMA_CTRL2_10GBCX4: |
224 | ecmd->port = PORT_OTHER; |
225 | ecmd->supported = 0; |
226 | ecmd->advertising = 0; |
227 | break; |
228 | |
229 | case MDIO_PMA_CTRL2_10GBKX4: |
230 | case MDIO_PMA_CTRL2_10GBKR: |
231 | case MDIO_PMA_CTRL2_1000BKX: |
232 | ecmd->port = PORT_OTHER; |
233 | ecmd->supported = SUPPORTED_Backplane; |
234 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
235 | MDIO_PMA_EXTABLE); |
236 | if (reg & MDIO_PMA_EXTABLE_10GBKX4) |
237 | ecmd->supported |= SUPPORTED_10000baseKX4_Full; |
238 | if (reg & MDIO_PMA_EXTABLE_10GBKR) |
239 | ecmd->supported |= SUPPORTED_10000baseKR_Full; |
240 | if (reg & MDIO_PMA_EXTABLE_1000BKX) |
241 | ecmd->supported |= SUPPORTED_1000baseKX_Full; |
242 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
243 | MDIO_PMA_10GBR_FECABLE); |
244 | if (reg & MDIO_PMA_10GBR_FECABLE_ABLE) |
245 | ecmd->supported |= SUPPORTED_10000baseR_FEC; |
246 | ecmd->advertising = ADVERTISED_Backplane; |
247 | break; |
248 | |
249 | /* All the other defined modes are flavours of optical */ |
250 | default: |
251 | ecmd->port = PORT_FIBRE; |
252 | ecmd->supported = SUPPORTED_FIBRE; |
253 | ecmd->advertising = ADVERTISED_FIBRE; |
254 | break; |
255 | } |
256 | |
257 | if (mdio->mmds & MDIO_DEVS_AN) { |
258 | ecmd->supported |= SUPPORTED_Autoneg; |
259 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_AN, |
260 | MDIO_CTRL1); |
261 | if (reg & MDIO_AN_CTRL1_ENABLE) { |
262 | ecmd->autoneg = AUTONEG_ENABLE; |
263 | ecmd->advertising |= |
264 | ADVERTISED_Autoneg | |
265 | mdio45_get_an(mdio, MDIO_AN_ADVERTISE) | |
266 | npage_adv; |
267 | } else { |
268 | ecmd->autoneg = AUTONEG_DISABLE; |
269 | } |
270 | } else { |
271 | ecmd->autoneg = AUTONEG_DISABLE; |
272 | } |
273 | |
274 | if (ecmd->autoneg) { |
275 | u32 modes = 0; |
276 | int an_stat = mdio->mdio_read(mdio->dev, mdio->prtad, |
277 | MDIO_MMD_AN, MDIO_STAT1); |
278 | |
279 | /* If AN is complete and successful, report best common |
280 | * mode, otherwise report best advertised mode. */ |
281 | if (an_stat & MDIO_AN_STAT1_COMPLETE) { |
282 | ecmd->lp_advertising = |
283 | mdio45_get_an(mdio, MDIO_AN_LPA) | npage_lpa; |
284 | if (an_stat & MDIO_AN_STAT1_LPABLE) |
285 | ecmd->lp_advertising |= ADVERTISED_Autoneg; |
286 | modes = ecmd->advertising & ecmd->lp_advertising; |
287 | } |
288 | if ((modes & ~ADVERTISED_Autoneg) == 0) |
289 | modes = ecmd->advertising; |
290 | |
291 | if (modes & (ADVERTISED_10000baseT_Full | |
292 | ADVERTISED_10000baseKX4_Full | |
293 | ADVERTISED_10000baseKR_Full)) { |
294 | speed = SPEED_10000; |
295 | ecmd->duplex = DUPLEX_FULL; |
296 | } else if (modes & (ADVERTISED_1000baseT_Full | |
297 | ADVERTISED_1000baseT_Half | |
298 | ADVERTISED_1000baseKX_Full)) { |
299 | speed = SPEED_1000; |
300 | ecmd->duplex = !(modes & ADVERTISED_1000baseT_Half); |
301 | } else if (modes & (ADVERTISED_100baseT_Full | |
302 | ADVERTISED_100baseT_Half)) { |
303 | speed = SPEED_100; |
304 | ecmd->duplex = !!(modes & ADVERTISED_100baseT_Full); |
305 | } else { |
306 | speed = SPEED_10; |
307 | ecmd->duplex = !!(modes & ADVERTISED_10baseT_Full); |
308 | } |
309 | } else { |
310 | /* Report forced settings */ |
311 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
312 | MDIO_CTRL1); |
313 | speed = (((reg & MDIO_PMA_CTRL1_SPEED1000) ? 100 : 1) |
314 | * ((reg & MDIO_PMA_CTRL1_SPEED100) ? 100 : 10)); |
315 | ecmd->duplex = (reg & MDIO_CTRL1_FULLDPLX || |
316 | speed == SPEED_10000); |
317 | } |
318 | |
319 | ethtool_cmd_speed_set(ep: ecmd, speed); |
320 | |
321 | /* 10GBASE-T MDI/MDI-X */ |
322 | if (ecmd->port == PORT_TP |
323 | && (ethtool_cmd_speed(ep: ecmd) == SPEED_10000)) { |
324 | switch (mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
325 | MDIO_PMA_10GBT_SWAPPOL)) { |
326 | case MDIO_PMA_10GBT_SWAPPOL_ABNX | MDIO_PMA_10GBT_SWAPPOL_CDNX: |
327 | ecmd->eth_tp_mdix = ETH_TP_MDI; |
328 | break; |
329 | case 0: |
330 | ecmd->eth_tp_mdix = ETH_TP_MDI_X; |
331 | break; |
332 | default: |
333 | /* It's complicated... */ |
334 | ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID; |
335 | break; |
336 | } |
337 | } |
338 | } |
339 | EXPORT_SYMBOL(mdio45_ethtool_gset_npage); |
340 | |
341 | /** |
342 | * mdio45_ethtool_ksettings_get_npage - get settings for ETHTOOL_GLINKSETTINGS |
343 | * @mdio: MDIO interface |
344 | * @cmd: Ethtool request structure |
345 | * @npage_adv: Modes currently advertised on next pages |
346 | * @npage_lpa: Modes advertised by link partner on next pages |
347 | * |
348 | * The @cmd parameter is expected to have been cleared before calling |
349 | * mdio45_ethtool_ksettings_get_npage(). |
350 | * |
351 | * Since the CSRs for auto-negotiation using next pages are not fully |
352 | * standardised, this function does not attempt to decode them. The |
353 | * caller must pass them in. |
354 | */ |
355 | void mdio45_ethtool_ksettings_get_npage(const struct mdio_if_info *mdio, |
356 | struct ethtool_link_ksettings *cmd, |
357 | u32 npage_adv, u32 npage_lpa) |
358 | { |
359 | int reg; |
360 | u32 speed, supported = 0, advertising = 0, lp_advertising = 0; |
361 | |
362 | BUILD_BUG_ON(MDIO_SUPPORTS_C22 != ETH_MDIO_SUPPORTS_C22); |
363 | BUILD_BUG_ON(MDIO_SUPPORTS_C45 != ETH_MDIO_SUPPORTS_C45); |
364 | |
365 | cmd->base.phy_address = mdio->prtad; |
366 | cmd->base.mdio_support = |
367 | mdio->mode_support & (MDIO_SUPPORTS_C45 | MDIO_SUPPORTS_C22); |
368 | |
369 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
370 | MDIO_CTRL2); |
371 | switch (reg & MDIO_PMA_CTRL2_TYPE) { |
372 | case MDIO_PMA_CTRL2_10GBT: |
373 | case MDIO_PMA_CTRL2_1000BT: |
374 | case MDIO_PMA_CTRL2_100BTX: |
375 | case MDIO_PMA_CTRL2_10BT: |
376 | cmd->base.port = PORT_TP; |
377 | supported = SUPPORTED_TP; |
378 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
379 | MDIO_SPEED); |
380 | if (reg & MDIO_SPEED_10G) |
381 | supported |= SUPPORTED_10000baseT_Full; |
382 | if (reg & MDIO_PMA_SPEED_1000) |
383 | supported |= (SUPPORTED_1000baseT_Full | |
384 | SUPPORTED_1000baseT_Half); |
385 | if (reg & MDIO_PMA_SPEED_100) |
386 | supported |= (SUPPORTED_100baseT_Full | |
387 | SUPPORTED_100baseT_Half); |
388 | if (reg & MDIO_PMA_SPEED_10) |
389 | supported |= (SUPPORTED_10baseT_Full | |
390 | SUPPORTED_10baseT_Half); |
391 | advertising = ADVERTISED_TP; |
392 | break; |
393 | |
394 | case MDIO_PMA_CTRL2_10GBCX4: |
395 | cmd->base.port = PORT_OTHER; |
396 | supported = 0; |
397 | advertising = 0; |
398 | break; |
399 | |
400 | case MDIO_PMA_CTRL2_10GBKX4: |
401 | case MDIO_PMA_CTRL2_10GBKR: |
402 | case MDIO_PMA_CTRL2_1000BKX: |
403 | cmd->base.port = PORT_OTHER; |
404 | supported = SUPPORTED_Backplane; |
405 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
406 | MDIO_PMA_EXTABLE); |
407 | if (reg & MDIO_PMA_EXTABLE_10GBKX4) |
408 | supported |= SUPPORTED_10000baseKX4_Full; |
409 | if (reg & MDIO_PMA_EXTABLE_10GBKR) |
410 | supported |= SUPPORTED_10000baseKR_Full; |
411 | if (reg & MDIO_PMA_EXTABLE_1000BKX) |
412 | supported |= SUPPORTED_1000baseKX_Full; |
413 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
414 | MDIO_PMA_10GBR_FECABLE); |
415 | if (reg & MDIO_PMA_10GBR_FECABLE_ABLE) |
416 | supported |= SUPPORTED_10000baseR_FEC; |
417 | advertising = ADVERTISED_Backplane; |
418 | break; |
419 | |
420 | /* All the other defined modes are flavours of optical */ |
421 | default: |
422 | cmd->base.port = PORT_FIBRE; |
423 | supported = SUPPORTED_FIBRE; |
424 | advertising = ADVERTISED_FIBRE; |
425 | break; |
426 | } |
427 | |
428 | if (mdio->mmds & MDIO_DEVS_AN) { |
429 | supported |= SUPPORTED_Autoneg; |
430 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_AN, |
431 | MDIO_CTRL1); |
432 | if (reg & MDIO_AN_CTRL1_ENABLE) { |
433 | cmd->base.autoneg = AUTONEG_ENABLE; |
434 | advertising |= |
435 | ADVERTISED_Autoneg | |
436 | mdio45_get_an(mdio, MDIO_AN_ADVERTISE) | |
437 | npage_adv; |
438 | } else { |
439 | cmd->base.autoneg = AUTONEG_DISABLE; |
440 | } |
441 | } else { |
442 | cmd->base.autoneg = AUTONEG_DISABLE; |
443 | } |
444 | |
445 | if (cmd->base.autoneg) { |
446 | u32 modes = 0; |
447 | int an_stat = mdio->mdio_read(mdio->dev, mdio->prtad, |
448 | MDIO_MMD_AN, MDIO_STAT1); |
449 | |
450 | /* If AN is complete and successful, report best common |
451 | * mode, otherwise report best advertised mode. |
452 | */ |
453 | if (an_stat & MDIO_AN_STAT1_COMPLETE) { |
454 | lp_advertising = |
455 | mdio45_get_an(mdio, MDIO_AN_LPA) | npage_lpa; |
456 | if (an_stat & MDIO_AN_STAT1_LPABLE) |
457 | lp_advertising |= ADVERTISED_Autoneg; |
458 | modes = advertising & lp_advertising; |
459 | } |
460 | if ((modes & ~ADVERTISED_Autoneg) == 0) |
461 | modes = advertising; |
462 | |
463 | if (modes & (ADVERTISED_10000baseT_Full | |
464 | ADVERTISED_10000baseKX4_Full | |
465 | ADVERTISED_10000baseKR_Full)) { |
466 | speed = SPEED_10000; |
467 | cmd->base.duplex = DUPLEX_FULL; |
468 | } else if (modes & (ADVERTISED_1000baseT_Full | |
469 | ADVERTISED_1000baseT_Half | |
470 | ADVERTISED_1000baseKX_Full)) { |
471 | speed = SPEED_1000; |
472 | cmd->base.duplex = !(modes & ADVERTISED_1000baseT_Half); |
473 | } else if (modes & (ADVERTISED_100baseT_Full | |
474 | ADVERTISED_100baseT_Half)) { |
475 | speed = SPEED_100; |
476 | cmd->base.duplex = !!(modes & ADVERTISED_100baseT_Full); |
477 | } else { |
478 | speed = SPEED_10; |
479 | cmd->base.duplex = !!(modes & ADVERTISED_10baseT_Full); |
480 | } |
481 | } else { |
482 | /* Report forced settings */ |
483 | reg = mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
484 | MDIO_CTRL1); |
485 | speed = (((reg & MDIO_PMA_CTRL1_SPEED1000) ? 100 : 1) |
486 | * ((reg & MDIO_PMA_CTRL1_SPEED100) ? 100 : 10)); |
487 | cmd->base.duplex = (reg & MDIO_CTRL1_FULLDPLX || |
488 | speed == SPEED_10000); |
489 | } |
490 | |
491 | cmd->base.speed = speed; |
492 | |
493 | ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.supported, |
494 | legacy_u32: supported); |
495 | ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.advertising, |
496 | legacy_u32: advertising); |
497 | ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.lp_advertising, |
498 | legacy_u32: lp_advertising); |
499 | |
500 | /* 10GBASE-T MDI/MDI-X */ |
501 | if (cmd->base.port == PORT_TP && (cmd->base.speed == SPEED_10000)) { |
502 | switch (mdio->mdio_read(mdio->dev, mdio->prtad, MDIO_MMD_PMAPMD, |
503 | MDIO_PMA_10GBT_SWAPPOL)) { |
504 | case MDIO_PMA_10GBT_SWAPPOL_ABNX | MDIO_PMA_10GBT_SWAPPOL_CDNX: |
505 | cmd->base.eth_tp_mdix = ETH_TP_MDI; |
506 | break; |
507 | case 0: |
508 | cmd->base.eth_tp_mdix = ETH_TP_MDI_X; |
509 | break; |
510 | default: |
511 | /* It's complicated... */ |
512 | cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; |
513 | break; |
514 | } |
515 | } |
516 | } |
517 | EXPORT_SYMBOL(mdio45_ethtool_ksettings_get_npage); |
518 | |
519 | /** |
520 | * mdio_mii_ioctl - MII ioctl interface for MDIO (clause 22 or 45) PHYs |
521 | * @mdio: MDIO interface |
522 | * @mii_data: MII ioctl data structure |
523 | * @cmd: MII ioctl command |
524 | * |
525 | * Returns 0 on success, negative on error. |
526 | */ |
527 | int mdio_mii_ioctl(const struct mdio_if_info *mdio, |
528 | struct mii_ioctl_data *mii_data, int cmd) |
529 | { |
530 | int prtad, devad; |
531 | u16 addr = mii_data->reg_num; |
532 | |
533 | /* Validate/convert cmd to one of SIOC{G,S}MIIREG */ |
534 | switch (cmd) { |
535 | case SIOCGMIIPHY: |
536 | if (mdio->prtad == MDIO_PRTAD_NONE) |
537 | return -EOPNOTSUPP; |
538 | mii_data->phy_id = mdio->prtad; |
539 | cmd = SIOCGMIIREG; |
540 | break; |
541 | case SIOCGMIIREG: |
542 | case SIOCSMIIREG: |
543 | break; |
544 | default: |
545 | return -EOPNOTSUPP; |
546 | } |
547 | |
548 | /* Validate/convert phy_id */ |
549 | if ((mdio->mode_support & MDIO_SUPPORTS_C45) && |
550 | mdio_phy_id_is_c45(phy_id: mii_data->phy_id)) { |
551 | prtad = mdio_phy_id_prtad(phy_id: mii_data->phy_id); |
552 | devad = mdio_phy_id_devad(phy_id: mii_data->phy_id); |
553 | } else if ((mdio->mode_support & MDIO_SUPPORTS_C22) && |
554 | mii_data->phy_id < 0x20) { |
555 | prtad = mii_data->phy_id; |
556 | devad = MDIO_DEVAD_NONE; |
557 | addr &= 0x1f; |
558 | } else if ((mdio->mode_support & MDIO_EMULATE_C22) && |
559 | mdio->prtad != MDIO_PRTAD_NONE && |
560 | mii_data->phy_id == mdio->prtad) { |
561 | /* Remap commonly-used MII registers. */ |
562 | prtad = mdio->prtad; |
563 | switch (addr) { |
564 | case MII_BMCR: |
565 | case MII_BMSR: |
566 | case MII_PHYSID1: |
567 | case MII_PHYSID2: |
568 | devad = __ffs(mdio->mmds); |
569 | break; |
570 | case MII_ADVERTISE: |
571 | case MII_LPA: |
572 | if (!(mdio->mmds & MDIO_DEVS_AN)) |
573 | return -EINVAL; |
574 | devad = MDIO_MMD_AN; |
575 | if (addr == MII_ADVERTISE) |
576 | addr = MDIO_AN_ADVERTISE; |
577 | else |
578 | addr = MDIO_AN_LPA; |
579 | break; |
580 | default: |
581 | return -EINVAL; |
582 | } |
583 | } else { |
584 | return -EINVAL; |
585 | } |
586 | |
587 | if (cmd == SIOCGMIIREG) { |
588 | int rc = mdio->mdio_read(mdio->dev, prtad, devad, addr); |
589 | if (rc < 0) |
590 | return rc; |
591 | mii_data->val_out = rc; |
592 | return 0; |
593 | } else { |
594 | return mdio->mdio_write(mdio->dev, prtad, devad, addr, |
595 | mii_data->val_in); |
596 | } |
597 | } |
598 | EXPORT_SYMBOL(mdio_mii_ioctl); |
599 | |