1 From e268be0ddc666f4a98db462cbed2a97637e82b5c Mon Sep 17 00:00:00 2001
2 From: Russell King <rmk+kernel@arm.linux.org.uk>
3 Date: Wed, 16 Sep 2015 21:27:10 +0100
4 Subject: [PATCH 722/744] net: mvneta: convert to phylink
6 Convert mvneta to use phylink, which models the MAC to PHY link in
7 a generic, reusable form.
9 Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
11 drivers/net/ethernet/marvell/Kconfig | 2 +-
12 drivers/net/ethernet/marvell/mvneta.c | 451 +++++++++++++++++-----------------
13 2 files changed, 227 insertions(+), 226 deletions(-)
15 --- a/drivers/net/ethernet/marvell/Kconfig
16 +++ b/drivers/net/ethernet/marvell/Kconfig
17 @@ -58,7 +58,7 @@ config MVNETA
18 tristate "Marvell Armada 370/38x/XP network interface support"
24 This driver supports the network interface units in the
25 Marvell ARMADA XP, ARMADA 370 and ARMADA 38x SoC family.
26 --- a/drivers/net/ethernet/marvell/mvneta.c
27 +++ b/drivers/net/ethernet/marvell/mvneta.c
29 #include <linux/of_mdio.h>
30 #include <linux/of_net.h>
31 #include <linux/phy.h>
32 +#include <linux/phylink.h>
33 #include <linux/platform_device.h>
34 #include <linux/skbuff.h>
37 #define MVNETA_GMAC_CTRL_0 0x2c00
38 #define MVNETA_GMAC_MAX_RX_SIZE_SHIFT 2
39 #define MVNETA_GMAC_MAX_RX_SIZE_MASK 0x7ffc
40 +#define MVNETA_GMAC0_PORT_1000BASE_X BIT(1)
41 #define MVNETA_GMAC0_PORT_ENABLE BIT(0)
42 #define MVNETA_GMAC_CTRL_2 0x2c08
43 #define MVNETA_GMAC2_INBAND_AN_ENABLE BIT(0)
45 #define MVNETA_GMAC_TX_FLOW_CTRL_ENABLE BIT(5)
46 #define MVNETA_GMAC_RX_FLOW_CTRL_ACTIVE BIT(6)
47 #define MVNETA_GMAC_TX_FLOW_CTRL_ACTIVE BIT(7)
48 +#define MVNETA_GMAC_AN_COMPLETE BIT(11)
49 +#define MVNETA_GMAC_SYNC_OK BIT(14)
50 #define MVNETA_GMAC_AUTONEG_CONFIG 0x2c0c
51 #define MVNETA_GMAC_FORCE_LINK_DOWN BIT(0)
52 #define MVNETA_GMAC_FORCE_LINK_PASS BIT(1)
53 #define MVNETA_GMAC_INBAND_AN_ENABLE BIT(2)
54 +#define MVNETA_GMAC_AN_BYPASS_ENABLE BIT(3)
55 +#define MVNETA_GMAC_INBAND_RESTART_AN BIT(4)
56 #define MVNETA_GMAC_CONFIG_MII_SPEED BIT(5)
57 #define MVNETA_GMAC_CONFIG_GMII_SPEED BIT(6)
58 #define MVNETA_GMAC_AN_SPEED_EN BIT(7)
59 +#define MVNETA_GMAC_CONFIG_FLOW_CTRL BIT(8)
60 +#define MVNETA_GMAC_ADVERT_SYM_FLOW_CTRL BIT(9)
61 #define MVNETA_GMAC_AN_FLOW_CTRL_EN BIT(11)
62 #define MVNETA_GMAC_CONFIG_FULL_DUPLEX BIT(12)
63 #define MVNETA_GMAC_AN_DUPLEX_EN BIT(13)
64 @@ -396,15 +404,9 @@ struct mvneta_port {
68 - struct mii_bus *mii_bus;
69 - struct phy_device *phy_dev;
70 - phy_interface_t phy_interface;
71 - struct device_node *phy_node;
73 - unsigned int duplex;
75 + struct device_node *dn;
76 unsigned int tx_csum_limit;
77 - unsigned int use_inband_status:1;
78 + struct phylink *phylink;
80 struct mvneta_bm *bm_priv;
81 struct mvneta_bm_pool *pool_long;
82 @@ -1177,10 +1179,6 @@ static void mvneta_port_disable(struct m
83 val &= ~MVNETA_GMAC0_PORT_ENABLE;
84 mvreg_write(pp, MVNETA_GMAC_CTRL_0, val);
93 @@ -1240,44 +1238,6 @@ static void mvneta_set_other_mcast_table
94 mvreg_write(pp, MVNETA_DA_FILT_OTH_MCAST + offset, val);
97 -static void mvneta_set_autoneg(struct mvneta_port *pp, int enable)
102 - val = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
103 - val &= ~(MVNETA_GMAC_FORCE_LINK_PASS |
104 - MVNETA_GMAC_FORCE_LINK_DOWN |
105 - MVNETA_GMAC_AN_FLOW_CTRL_EN);
106 - val |= MVNETA_GMAC_INBAND_AN_ENABLE |
107 - MVNETA_GMAC_AN_SPEED_EN |
108 - MVNETA_GMAC_AN_DUPLEX_EN;
109 - mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, val);
111 - val = mvreg_read(pp, MVNETA_GMAC_CLOCK_DIVIDER);
112 - val |= MVNETA_GMAC_1MS_CLOCK_ENABLE;
113 - mvreg_write(pp, MVNETA_GMAC_CLOCK_DIVIDER, val);
115 - val = mvreg_read(pp, MVNETA_GMAC_CTRL_2);
116 - val |= MVNETA_GMAC2_INBAND_AN_ENABLE;
117 - mvreg_write(pp, MVNETA_GMAC_CTRL_2, val);
119 - val = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
120 - val &= ~(MVNETA_GMAC_INBAND_AN_ENABLE |
121 - MVNETA_GMAC_AN_SPEED_EN |
122 - MVNETA_GMAC_AN_DUPLEX_EN);
123 - mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, val);
125 - val = mvreg_read(pp, MVNETA_GMAC_CLOCK_DIVIDER);
126 - val &= ~MVNETA_GMAC_1MS_CLOCK_ENABLE;
127 - mvreg_write(pp, MVNETA_GMAC_CLOCK_DIVIDER, val);
129 - val = mvreg_read(pp, MVNETA_GMAC_CTRL_2);
130 - val &= ~MVNETA_GMAC2_INBAND_AN_ENABLE;
131 - mvreg_write(pp, MVNETA_GMAC_CTRL_2, val);
135 static void mvneta_percpu_unmask_interrupt(void *arg)
137 struct mvneta_port *pp = arg;
138 @@ -1425,7 +1385,6 @@ static void mvneta_defaults_set(struct m
139 val &= ~MVNETA_PHY_POLLING_ENABLE;
140 mvreg_write(pp, MVNETA_UNIT_CONTROL, val);
142 - mvneta_set_autoneg(pp, pp->use_inband_status);
143 mvneta_set_ucast_table(pp, -1);
144 mvneta_set_special_mcast_table(pp, -1);
145 mvneta_set_other_mcast_table(pp, -1);
146 @@ -2618,26 +2577,11 @@ static irqreturn_t mvneta_isr(int irq, v
150 -static int mvneta_fixed_link_update(struct mvneta_port *pp,
151 - struct phy_device *phy)
152 +static void mvneta_link_change(struct mvneta_port *pp)
154 - struct fixed_phy_status status;
155 - struct fixed_phy_status changed = {};
156 u32 gmac_stat = mvreg_read(pp, MVNETA_GMAC_STATUS);
158 - status.link = !!(gmac_stat & MVNETA_GMAC_LINK_UP);
159 - if (gmac_stat & MVNETA_GMAC_SPEED_1000)
160 - status.speed = SPEED_1000;
161 - else if (gmac_stat & MVNETA_GMAC_SPEED_100)
162 - status.speed = SPEED_100;
164 - status.speed = SPEED_10;
165 - status.duplex = !!(gmac_stat & MVNETA_GMAC_FULL_DUPLEX);
168 - changed.duplex = 1;
169 - fixed_phy_update_state(phy, &status, &changed);
171 + phylink_mac_change(pp->phylink, !!(gmac_stat & MVNETA_GMAC_LINK_UP));
175 @@ -2666,12 +2610,11 @@ static int mvneta_poll(struct napi_struc
176 u32 cause_misc = mvreg_read(pp, MVNETA_INTR_MISC_CAUSE);
178 mvreg_write(pp, MVNETA_INTR_MISC_CAUSE, 0);
179 - if (pp->use_inband_status && (cause_misc &
180 - (MVNETA_CAUSE_PHY_STATUS_CHANGE |
181 - MVNETA_CAUSE_LINK_CHANGE |
182 - MVNETA_CAUSE_PSC_SYNC_CHANGE))) {
183 - mvneta_fixed_link_update(pp, pp->phy_dev);
186 + if (cause_misc & (MVNETA_CAUSE_PHY_STATUS_CHANGE |
187 + MVNETA_CAUSE_LINK_CHANGE |
188 + MVNETA_CAUSE_PSC_SYNC_CHANGE))
189 + mvneta_link_change(pp);
192 /* Release Tx descriptors */
193 @@ -2987,7 +2930,7 @@ static void mvneta_start_dev(struct mvne
194 MVNETA_CAUSE_LINK_CHANGE |
195 MVNETA_CAUSE_PSC_SYNC_CHANGE);
197 - phy_start(pp->phy_dev);
198 + phylink_start(pp->phylink);
199 netif_tx_start_all_queues(pp->dev);
202 @@ -2995,7 +2938,7 @@ static void mvneta_stop_dev(struct mvnet
206 - phy_stop(pp->phy_dev);
207 + phylink_stop(pp->phylink);
209 for_each_online_cpu(cpu) {
210 struct mvneta_pcpu_port *port = per_cpu_ptr(pp->ports, cpu);
211 @@ -3165,99 +3108,219 @@ static int mvneta_set_mac_addr(struct ne
215 -static void mvneta_adjust_link(struct net_device *ndev)
216 +static int mvneta_mac_support(struct net_device *ndev, unsigned int mode,
217 + struct phylink_link_state *state)
221 + state->supported = SUPPORTED_1000baseT_Full |
222 + SUPPORTED_Autoneg | SUPPORTED_Pause;
223 + state->advertising = ADVERTISED_1000baseT_Full |
224 + ADVERTISED_Autoneg | ADVERTISED_Pause;
225 + state->an_enabled = 1;
232 + state->supported = PHY_10BT_FEATURES |
233 + PHY_100BT_FEATURES |
234 + SUPPORTED_1000baseT_Full |
236 + state->advertising = ADVERTISED_10baseT_Half |
237 + ADVERTISED_10baseT_Full |
238 + ADVERTISED_100baseT_Half |
239 + ADVERTISED_100baseT_Full |
240 + ADVERTISED_1000baseT_Full |
241 + ADVERTISED_Autoneg;
242 + state->an_enabled = 1;
248 +static int mvneta_mac_link_state(struct net_device *ndev,
249 + struct phylink_link_state *state)
251 struct mvneta_port *pp = netdev_priv(ndev);
252 - struct phy_device *phydev = pp->phy_dev;
253 - int status_change = 0;
256 - if (phydev->link) {
257 - if ((pp->speed != phydev->speed) ||
258 - (pp->duplex != phydev->duplex)) {
261 - val = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
262 - val &= ~(MVNETA_GMAC_CONFIG_MII_SPEED |
263 - MVNETA_GMAC_CONFIG_GMII_SPEED |
264 - MVNETA_GMAC_CONFIG_FULL_DUPLEX);
266 - if (phydev->duplex)
267 - val |= MVNETA_GMAC_CONFIG_FULL_DUPLEX;
269 - if (phydev->speed == SPEED_1000)
270 - val |= MVNETA_GMAC_CONFIG_GMII_SPEED;
271 - else if (phydev->speed == SPEED_100)
272 - val |= MVNETA_GMAC_CONFIG_MII_SPEED;
273 + gmac_stat = mvreg_read(pp, MVNETA_GMAC_STATUS);
275 - mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, val);
276 + if (gmac_stat & MVNETA_GMAC_SPEED_1000)
277 + state->speed = SPEED_1000;
278 + else if (gmac_stat & MVNETA_GMAC_SPEED_100)
279 + state->speed = SPEED_100;
281 + state->speed = SPEED_10;
283 - pp->duplex = phydev->duplex;
284 - pp->speed = phydev->speed;
286 + state->an_complete = !!(gmac_stat & MVNETA_GMAC_AN_COMPLETE);
287 + state->sync = !!(gmac_stat & MVNETA_GMAC_SYNC_OK);
288 + state->link = !!(gmac_stat & MVNETA_GMAC_LINK_UP);
289 + state->duplex = !!(gmac_stat & MVNETA_GMAC_FULL_DUPLEX);
292 + if (gmac_stat & MVNETA_GMAC_RX_FLOW_CTRL_ENABLE)
293 + state->pause |= MLO_PAUSE_RX;
294 + if (gmac_stat & MVNETA_GMAC_TX_FLOW_CTRL_ENABLE)
295 + state->pause |= MLO_PAUSE_TX;
300 +static void mvneta_mac_an_restart(struct net_device *ndev, unsigned int mode)
302 + struct mvneta_port *pp = netdev_priv(ndev);
304 + if (mode == MLO_AN_8023Z) {
305 + u32 gmac_an = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
307 + mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG,
308 + gmac_an | MVNETA_GMAC_INBAND_RESTART_AN);
309 + mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG,
310 + gmac_an & ~MVNETA_GMAC_INBAND_RESTART_AN);
314 - if (phydev->link != pp->link) {
315 - if (!phydev->link) {
319 +static void mvneta_mac_config(struct net_device *ndev, unsigned int mode,
320 + const struct phylink_link_state *state)
322 + struct mvneta_port *pp = netdev_priv(ndev);
323 + u32 new_ctrl0, gmac_ctrl0 = mvreg_read(pp, MVNETA_GMAC_CTRL_0);
324 + u32 new_ctrl2, gmac_ctrl2 = mvreg_read(pp, MVNETA_GMAC_CTRL_2);
325 + u32 new_clk, gmac_clk = mvreg_read(pp, MVNETA_GMAC_CLOCK_DIVIDER);
326 + u32 new_an, gmac_an = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
328 + new_ctrl0 = gmac_ctrl0 & ~MVNETA_GMAC0_PORT_1000BASE_X;
329 + new_ctrl2 = gmac_ctrl2 & ~MVNETA_GMAC2_INBAND_AN_ENABLE;
330 + new_clk = gmac_clk & ~MVNETA_GMAC_1MS_CLOCK_ENABLE;
331 + new_an = gmac_an & ~(MVNETA_GMAC_INBAND_AN_ENABLE |
332 + MVNETA_GMAC_INBAND_RESTART_AN |
333 + MVNETA_GMAC_CONFIG_MII_SPEED |
334 + MVNETA_GMAC_CONFIG_GMII_SPEED |
335 + MVNETA_GMAC_AN_SPEED_EN |
336 + MVNETA_GMAC_ADVERT_SYM_FLOW_CTRL |
337 + MVNETA_GMAC_CONFIG_FLOW_CTRL |
338 + MVNETA_GMAC_AN_FLOW_CTRL_EN |
339 + MVNETA_GMAC_CONFIG_FULL_DUPLEX |
340 + MVNETA_GMAC_AN_DUPLEX_EN);
342 + if (state->advertising & ADVERTISED_Pause)
343 + new_an |= MVNETA_GMAC_ADVERT_SYM_FLOW_CTRL;
347 + /* SGMII mode receives the state from the PHY */
348 + new_ctrl2 |= MVNETA_GMAC2_INBAND_AN_ENABLE;
349 + new_clk |= MVNETA_GMAC_1MS_CLOCK_ENABLE;
350 + new_an = (new_an & ~(MVNETA_GMAC_FORCE_LINK_DOWN |
351 + MVNETA_GMAC_FORCE_LINK_PASS)) |
352 + MVNETA_GMAC_INBAND_AN_ENABLE |
353 + MVNETA_GMAC_AN_SPEED_EN |
354 + MVNETA_GMAC_AN_DUPLEX_EN;
358 + /* 802.3z negotiation - only 1000base-X */
359 + new_ctrl0 |= MVNETA_GMAC0_PORT_1000BASE_X;
360 + new_clk |= MVNETA_GMAC_1MS_CLOCK_ENABLE;
361 + new_an = (new_an & ~(MVNETA_GMAC_FORCE_LINK_DOWN |
362 + MVNETA_GMAC_FORCE_LINK_PASS)) |
363 + MVNETA_GMAC_INBAND_AN_ENABLE |
364 + MVNETA_GMAC_CONFIG_GMII_SPEED |
365 + /* The MAC only supports FD mode */
366 + MVNETA_GMAC_CONFIG_FULL_DUPLEX;
368 + if (state->an_enabled)
369 + new_an |= MVNETA_GMAC_AN_FLOW_CTRL_EN;
372 - pp->link = phydev->link;
375 + /* Phy or fixed speed */
377 + new_an |= MVNETA_GMAC_CONFIG_FULL_DUPLEX;
379 + if (state->speed == SPEED_1000)
380 + new_an |= MVNETA_GMAC_CONFIG_GMII_SPEED;
381 + else if (state->speed == SPEED_100)
382 + new_an |= MVNETA_GMAC_CONFIG_MII_SPEED;
386 - if (status_change) {
387 - if (phydev->link) {
388 - if (!pp->use_inband_status) {
389 - u32 val = mvreg_read(pp,
390 - MVNETA_GMAC_AUTONEG_CONFIG);
391 - val &= ~MVNETA_GMAC_FORCE_LINK_DOWN;
392 - val |= MVNETA_GMAC_FORCE_LINK_PASS;
393 - mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG,
396 - mvneta_port_up(pp);
398 - if (!pp->use_inband_status) {
399 - u32 val = mvreg_read(pp,
400 - MVNETA_GMAC_AUTONEG_CONFIG);
401 - val &= ~MVNETA_GMAC_FORCE_LINK_PASS;
402 - val |= MVNETA_GMAC_FORCE_LINK_DOWN;
403 - mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG,
406 - mvneta_port_down(pp);
408 - phy_print_status(phydev);
409 + /* Armada 370 documentation says we can only change the port mode
410 + * and in-band enable when the link is down, so force it down
411 + * while making these changes. We also do this for GMAC_CTRL2 */
412 + if ((new_ctrl0 ^ gmac_ctrl0) & MVNETA_GMAC0_PORT_1000BASE_X ||
413 + (new_ctrl2 ^ gmac_ctrl2) & MVNETA_GMAC2_INBAND_AN_ENABLE ||
414 + (new_an ^ gmac_an) & MVNETA_GMAC_INBAND_AN_ENABLE) {
415 + mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG,
416 + (gmac_an & ~MVNETA_GMAC_FORCE_LINK_PASS) |
417 + MVNETA_GMAC_FORCE_LINK_DOWN);
420 + if (new_ctrl0 != gmac_ctrl0)
421 + mvreg_write(pp, MVNETA_GMAC_CTRL_0, new_ctrl0);
422 + if (new_ctrl2 != gmac_ctrl2)
423 + mvreg_write(pp, MVNETA_GMAC_CTRL_2, new_ctrl2);
424 + if (new_clk != gmac_clk)
425 + mvreg_write(pp, MVNETA_GMAC_CLOCK_DIVIDER, new_clk);
426 + if (new_an != gmac_an)
427 + mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, new_an);
430 +static void mvneta_mac_link_down(struct net_device *ndev, unsigned int mode)
432 + struct mvneta_port *pp = netdev_priv(ndev);
435 + mvneta_port_down(pp);
437 + if (mode == MLO_AN_PHY || mode == MLO_AN_FIXED) {
438 + val = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
439 + val &= ~MVNETA_GMAC_FORCE_LINK_PASS;
440 + val |= MVNETA_GMAC_FORCE_LINK_DOWN;
441 + mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, val);
445 -static int mvneta_mdio_probe(struct mvneta_port *pp)
446 +static void mvneta_mac_link_up(struct net_device *ndev, unsigned int mode,
447 + struct phy_device *phy)
449 - struct phy_device *phy_dev;
450 + struct mvneta_port *pp = netdev_priv(ndev);
453 - phy_dev = of_phy_connect(pp->dev, pp->phy_node, mvneta_adjust_link, 0,
454 - pp->phy_interface);
456 - netdev_err(pp->dev, "could not find the PHY\n");
460 - phy_dev->supported &= PHY_GBIT_FEATURES;
461 - phy_dev->advertising = phy_dev->supported;
463 - pp->phy_dev = phy_dev;
467 + if (mode == MLO_AN_PHY || mode == MLO_AN_FIXED) {
468 + val = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
469 + val &= ~MVNETA_GMAC_FORCE_LINK_DOWN;
470 + val |= MVNETA_GMAC_FORCE_LINK_PASS;
471 + mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, val);
475 + mvneta_port_up(pp);
478 +static const struct phylink_mac_ops mvneta_phylink_ops = {
479 + .mac_get_support = mvneta_mac_support,
480 + .mac_link_state = mvneta_mac_link_state,
481 + .mac_an_restart = mvneta_mac_an_restart,
482 + .mac_config = mvneta_mac_config,
483 + .mac_link_down = mvneta_mac_link_down,
484 + .mac_link_up = mvneta_mac_link_up,
487 +static int mvneta_mdio_probe(struct mvneta_port *pp)
489 + int err = phylink_of_phy_connect(pp->phylink, pp->dn);
491 + netdev_err(pp->dev, "could not attach PHY\n");
496 static void mvneta_mdio_remove(struct mvneta_port *pp)
498 - phy_disconnect(pp->phy_dev);
499 - pp->phy_dev = NULL;
500 + phylink_disconnect_phy(pp->phylink);
503 /* Electing a CPU must be done in an atomic way: it should be done
504 @@ -3505,10 +3568,7 @@ static int mvneta_ioctl(struct net_devic
506 struct mvneta_port *pp = netdev_priv(dev);
511 - return phy_mii_ioctl(pp->phy_dev, ifr, cmd);
512 + return phylink_mii_ioctl(pp->phylink, ifr, cmd);
515 /* Ethtool methods */
516 @@ -3518,54 +3578,15 @@ int mvneta_ethtool_get_settings(struct n
518 struct mvneta_port *pp = netdev_priv(dev);
523 - return phy_ethtool_gset(pp->phy_dev, cmd);
524 + return phylink_ethtool_get_settings(pp->phylink, cmd);
527 /* Set settings (phy address, speed) for ethtools */
528 int mvneta_ethtool_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
530 struct mvneta_port *pp = netdev_priv(dev);
531 - struct phy_device *phydev = pp->phy_dev;
536 - if ((cmd->autoneg == AUTONEG_ENABLE) != pp->use_inband_status) {
539 - mvneta_set_autoneg(pp, cmd->autoneg == AUTONEG_ENABLE);
541 - if (cmd->autoneg == AUTONEG_DISABLE) {
542 - val = mvreg_read(pp, MVNETA_GMAC_AUTONEG_CONFIG);
543 - val &= ~(MVNETA_GMAC_CONFIG_MII_SPEED |
544 - MVNETA_GMAC_CONFIG_GMII_SPEED |
545 - MVNETA_GMAC_CONFIG_FULL_DUPLEX);
547 - if (phydev->duplex)
548 - val |= MVNETA_GMAC_CONFIG_FULL_DUPLEX;
550 - if (phydev->speed == SPEED_1000)
551 - val |= MVNETA_GMAC_CONFIG_GMII_SPEED;
552 - else if (phydev->speed == SPEED_100)
553 - val |= MVNETA_GMAC_CONFIG_MII_SPEED;
555 - mvreg_write(pp, MVNETA_GMAC_AUTONEG_CONFIG, val);
558 - pp->use_inband_status = (cmd->autoneg == AUTONEG_ENABLE);
559 - netdev_info(pp->dev, "autoneg status set to %i\n",
560 - pp->use_inband_status);
562 - if (netif_running(dev)) {
563 - mvneta_port_down(pp);
564 - mvneta_port_up(pp);
568 - return phy_ethtool_sset(pp->phy_dev, cmd);
569 + return phylink_ethtool_set_settings(pp->phylink, cmd);
572 /* Set interrupt coalescing for ethtools */
573 @@ -3673,7 +3694,8 @@ static void mvneta_ethtool_update_stats(
575 const struct mvneta_statistic *s;
576 void __iomem *base = pp->base;
577 - u32 high, low, val;
583 @@ -3968,14 +3990,13 @@ static int mvneta_probe(struct platform_
584 const struct mbus_dram_target_info *dram_target_info;
585 struct resource *res;
586 struct device_node *dn = pdev->dev.of_node;
587 - struct device_node *phy_node;
588 struct device_node *bm_node;
589 struct mvneta_port *pp;
590 struct net_device *dev;
591 + struct phylink *phylink;
592 const char *dt_mac_addr;
593 char hw_mac_addr[ETH_ALEN];
594 const char *mac_from;
595 - const char *managed;
599 @@ -3991,31 +4012,11 @@ static int mvneta_probe(struct platform_
600 goto err_free_netdev;
603 - phy_node = of_parse_phandle(dn, "phy", 0);
605 - if (!of_phy_is_fixed_link(dn)) {
606 - dev_err(&pdev->dev, "no PHY specified\n");
611 - err = of_phy_register_fixed_link(dn);
613 - dev_err(&pdev->dev, "cannot register fixed PHY\n");
617 - /* In the case of a fixed PHY, the DT node associated
618 - * to the PHY is the Ethernet MAC DT node.
620 - phy_node = of_node_get(dn);
623 phy_mode = of_get_phy_mode(dn);
625 dev_err(&pdev->dev, "incorrect phy-mode\n");
627 - goto err_put_phy_node;
631 dev->tx_queue_len = MVNETA_MAX_TXD;
632 @@ -4026,12 +4027,7 @@ static int mvneta_probe(struct platform_
634 pp = netdev_priv(dev);
635 spin_lock_init(&pp->lock);
636 - pp->phy_node = phy_node;
637 - pp->phy_interface = phy_mode;
639 - err = of_property_read_string(dn, "managed", &managed);
640 - pp->use_inband_status = (err == 0 &&
641 - strcmp(managed, "in-band-status") == 0);
643 pp->cpu_notifier.notifier_call = mvneta_percpu_notifier;
645 pp->rxq_def = rxq_def;
646 @@ -4041,7 +4037,7 @@ static int mvneta_probe(struct platform_
647 pp->clk = devm_clk_get(&pdev->dev, NULL);
648 if (IS_ERR(pp->clk)) {
649 err = PTR_ERR(pp->clk);
650 - goto err_put_phy_node;
654 clk_prepare_enable(pp->clk);
655 @@ -4144,6 +4140,14 @@ static int mvneta_probe(struct platform_
656 dev->priv_flags |= IFF_UNICAST_FLT | IFF_LIVE_ADDR_CHANGE;
657 dev->gso_max_segs = MVNETA_MAX_TSO_SEGS;
659 + phylink = phylink_create(dev, dn, phy_mode, &mvneta_phylink_ops);
660 + if (IS_ERR(phylink)) {
661 + err = PTR_ERR(phylink);
662 + goto err_free_stats;
665 + pp->phylink = phylink;
667 err = register_netdev(dev);
669 dev_err(&pdev->dev, "failed to register\n");
670 @@ -4155,13 +4159,6 @@ static int mvneta_probe(struct platform_
672 platform_set_drvdata(pdev, pp->dev);
674 - if (pp->use_inband_status) {
675 - struct phy_device *phy = of_phy_find_device(dn);
677 - mvneta_fixed_link_update(pp, phy);
679 - put_device(&phy->dev);
684 @@ -4173,13 +4170,13 @@ err_netdev:
689 + phylink_destroy(pp->phylink);
690 free_percpu(pp->stats);
692 free_percpu(pp->ports);
694 clk_disable_unprepare(pp->clk);
696 - of_node_put(phy_node);
698 irq_dispose_mapping(dev->irq);
700 @@ -4198,7 +4195,7 @@ static int mvneta_remove(struct platform
701 free_percpu(pp->ports);
702 free_percpu(pp->stats);
703 irq_dispose_mapping(dev->irq);
704 - of_node_put(pp->phy_node);
705 + phylink_destroy(pp->phylink);