Merge branch 'irq-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6] / drivers / net / sfc / mdio_10g.c
1 /****************************************************************************
2  * Driver for Solarflare Solarstorm network controllers and boards
3  * Copyright 2006-2008 Solarflare Communications Inc.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published
7  * by the Free Software Foundation, incorporated herein by reference.
8  */
9 /*
10  * Useful functions for working with MDIO clause 45 PHYs
11  */
12 #include <linux/types.h>
13 #include <linux/ethtool.h>
14 #include <linux/delay.h>
15 #include "net_driver.h"
16 #include "mdio_10g.h"
17 #include "boards.h"
18
19 int mdio_clause45_reset_mmd(struct efx_nic *port, int mmd,
20                             int spins, int spintime)
21 {
22         u32 ctrl;
23         int phy_id = port->mii.phy_id;
24
25         /* Catch callers passing values in the wrong units (or just silly) */
26         EFX_BUG_ON_PARANOID(spins * spintime >= 5000);
27
28         mdio_clause45_write(port, phy_id, mmd, MDIO_MMDREG_CTRL1,
29                             (1 << MDIO_MMDREG_CTRL1_RESET_LBN));
30         /* Wait for the reset bit to clear. */
31         do {
32                 msleep(spintime);
33                 ctrl = mdio_clause45_read(port, phy_id, mmd, MDIO_MMDREG_CTRL1);
34                 spins--;
35
36         } while (spins && (ctrl & (1 << MDIO_MMDREG_CTRL1_RESET_LBN)));
37
38         return spins ? spins : -ETIMEDOUT;
39 }
40
41 static int mdio_clause45_check_mmd(struct efx_nic *efx, int mmd,
42                                    int fault_fatal)
43 {
44         int status;
45         int phy_id = efx->mii.phy_id;
46
47         if (LOOPBACK_INTERNAL(efx))
48                 return 0;
49
50         if (mmd != MDIO_MMD_AN) {
51                 /* Read MMD STATUS2 to check it is responding. */
52                 status = mdio_clause45_read(efx, phy_id, mmd,
53                                             MDIO_MMDREG_STAT2);
54                 if (((status >> MDIO_MMDREG_STAT2_PRESENT_LBN) &
55                      ((1 << MDIO_MMDREG_STAT2_PRESENT_WIDTH) - 1)) !=
56                     MDIO_MMDREG_STAT2_PRESENT_VAL) {
57                         EFX_ERR(efx, "PHY MMD %d not responding.\n", mmd);
58                         return -EIO;
59                 }
60         }
61
62         /* Read MMD STATUS 1 to check for fault. */
63         status = mdio_clause45_read(efx, phy_id, mmd, MDIO_MMDREG_STAT1);
64         if ((status & (1 << MDIO_MMDREG_STAT1_FAULT_LBN)) != 0) {
65                 if (fault_fatal) {
66                         EFX_ERR(efx, "PHY MMD %d reporting fatal"
67                                 " fault: status %x\n", mmd, status);
68                         return -EIO;
69                 } else {
70                         EFX_LOG(efx, "PHY MMD %d reporting status"
71                                 " %x (expected)\n", mmd, status);
72                 }
73         }
74         return 0;
75 }
76
77 /* This ought to be ridiculous overkill. We expect it to fail rarely */
78 #define MDIO45_RESET_TIME       1000 /* ms */
79 #define MDIO45_RESET_ITERS      100
80
81 int mdio_clause45_wait_reset_mmds(struct efx_nic *efx,
82                                   unsigned int mmd_mask)
83 {
84         const int spintime = MDIO45_RESET_TIME / MDIO45_RESET_ITERS;
85         int tries = MDIO45_RESET_ITERS;
86         int rc = 0;
87         int in_reset;
88
89         while (tries) {
90                 int mask = mmd_mask;
91                 int mmd = 0;
92                 int stat;
93                 in_reset = 0;
94                 while (mask) {
95                         if (mask & 1) {
96                                 stat = mdio_clause45_read(efx,
97                                                           efx->mii.phy_id,
98                                                           mmd,
99                                                           MDIO_MMDREG_CTRL1);
100                                 if (stat < 0) {
101                                         EFX_ERR(efx, "failed to read status of"
102                                                 " MMD %d\n", mmd);
103                                         return -EIO;
104                                 }
105                                 if (stat & (1 << MDIO_MMDREG_CTRL1_RESET_LBN))
106                                         in_reset |= (1 << mmd);
107                         }
108                         mask = mask >> 1;
109                         mmd++;
110                 }
111                 if (!in_reset)
112                         break;
113                 tries--;
114                 msleep(spintime);
115         }
116         if (in_reset != 0) {
117                 EFX_ERR(efx, "not all MMDs came out of reset in time."
118                         " MMDs still in reset: %x\n", in_reset);
119                 rc = -ETIMEDOUT;
120         }
121         return rc;
122 }
123
124 int mdio_clause45_check_mmds(struct efx_nic *efx,
125                              unsigned int mmd_mask, unsigned int fatal_mask)
126 {
127         u32 devices;
128         int mmd = 0, probe_mmd;
129
130         /* Historically we have probed the PHYXS to find out what devices are
131          * present,but that doesn't work so well if the PHYXS isn't expected
132          * to exist, if so just find the first item in the list supplied. */
133         probe_mmd = (mmd_mask & MDIO_MMDREG_DEVS_PHYXS) ? MDIO_MMD_PHYXS :
134             __ffs(mmd_mask);
135         devices = (mdio_clause45_read(efx, efx->mii.phy_id,
136                                       probe_mmd, MDIO_MMDREG_DEVS0) |
137                    mdio_clause45_read(efx, efx->mii.phy_id,
138                                       probe_mmd, MDIO_MMDREG_DEVS1) << 16);
139
140         /* Check all the expected MMDs are present */
141         if (devices < 0) {
142                 EFX_ERR(efx, "failed to read devices present\n");
143                 return -EIO;
144         }
145         if ((devices & mmd_mask) != mmd_mask) {
146                 EFX_ERR(efx, "required MMDs not present: got %x, "
147                         "wanted %x\n", devices, mmd_mask);
148                 return -ENODEV;
149         }
150         EFX_TRACE(efx, "Devices present: %x\n", devices);
151
152         /* Check all required MMDs are responding and happy. */
153         while (mmd_mask) {
154                 if (mmd_mask & 1) {
155                         int fault_fatal = fatal_mask & 1;
156                         if (mdio_clause45_check_mmd(efx, mmd, fault_fatal))
157                                 return -EIO;
158                 }
159                 mmd_mask = mmd_mask >> 1;
160                 fatal_mask = fatal_mask >> 1;
161                 mmd++;
162         }
163
164         return 0;
165 }
166
167 bool mdio_clause45_links_ok(struct efx_nic *efx, unsigned int mmd_mask)
168 {
169         int phy_id = efx->mii.phy_id;
170         u32 reg;
171         bool ok = true;
172         int mmd = 0;
173
174         /* If the port is in loopback, then we should only consider a subset
175          * of mmd's */
176         if (LOOPBACK_INTERNAL(efx))
177                 return true;
178         else if (efx->loopback_mode == LOOPBACK_NETWORK)
179                 return false;
180         else if (efx_phy_mode_disabled(efx->phy_mode))
181                 return false;
182         else if (efx->loopback_mode == LOOPBACK_PHYXS) {
183                 mmd_mask &= ~(MDIO_MMDREG_DEVS_PHYXS |
184                               MDIO_MMDREG_DEVS_PCS |
185                               MDIO_MMDREG_DEVS_PMAPMD |
186                               MDIO_MMDREG_DEVS_AN);
187                 if (!mmd_mask) {
188                         reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PHYXS,
189                                                  MDIO_PHYXS_STATUS2);
190                         return !(reg & (1 << MDIO_PHYXS_STATUS2_RX_FAULT_LBN));
191                 }
192         } else if (efx->loopback_mode == LOOPBACK_PCS)
193                 mmd_mask &= ~(MDIO_MMDREG_DEVS_PCS |
194                               MDIO_MMDREG_DEVS_PMAPMD |
195                               MDIO_MMDREG_DEVS_AN);
196         else if (efx->loopback_mode == LOOPBACK_PMAPMD)
197                 mmd_mask &= ~(MDIO_MMDREG_DEVS_PMAPMD |
198                               MDIO_MMDREG_DEVS_AN);
199
200         while (mmd_mask) {
201                 if (mmd_mask & 1) {
202                         /* Double reads because link state is latched, and a
203                          * read moves the current state into the register */
204                         reg = mdio_clause45_read(efx, phy_id,
205                                                  mmd, MDIO_MMDREG_STAT1);
206                         reg = mdio_clause45_read(efx, phy_id,
207                                                  mmd, MDIO_MMDREG_STAT1);
208                         ok = ok && (reg & (1 << MDIO_MMDREG_STAT1_LINK_LBN));
209                 }
210                 mmd_mask = (mmd_mask >> 1);
211                 mmd++;
212         }
213         return ok;
214 }
215
216 void mdio_clause45_transmit_disable(struct efx_nic *efx)
217 {
218         mdio_clause45_set_flag(efx, efx->mii.phy_id, MDIO_MMD_PMAPMD,
219                                MDIO_MMDREG_TXDIS, MDIO_MMDREG_TXDIS_GLOBAL_LBN,
220                                efx->phy_mode & PHY_MODE_TX_DISABLED);
221 }
222
223 void mdio_clause45_phy_reconfigure(struct efx_nic *efx)
224 {
225         int phy_id = efx->mii.phy_id;
226
227         mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_PMAPMD,
228                                MDIO_MMDREG_CTRL1, MDIO_PMAPMD_CTRL1_LBACK_LBN,
229                                efx->loopback_mode == LOOPBACK_PMAPMD);
230         mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_PCS,
231                                MDIO_MMDREG_CTRL1, MDIO_MMDREG_CTRL1_LBACK_LBN,
232                                efx->loopback_mode == LOOPBACK_PCS);
233         mdio_clause45_set_flag(efx, phy_id, MDIO_MMD_PHYXS,
234                                MDIO_MMDREG_CTRL1, MDIO_MMDREG_CTRL1_LBACK_LBN,
235                                efx->loopback_mode == LOOPBACK_NETWORK);
236 }
237
238 static void mdio_clause45_set_mmd_lpower(struct efx_nic *efx,
239                                          int lpower, int mmd)
240 {
241         int phy = efx->mii.phy_id;
242         int stat = mdio_clause45_read(efx, phy, mmd, MDIO_MMDREG_STAT1);
243
244         EFX_TRACE(efx, "Setting low power mode for MMD %d to %d\n",
245                   mmd, lpower);
246
247         if (stat & (1 << MDIO_MMDREG_STAT1_LPABLE_LBN)) {
248                 mdio_clause45_set_flag(efx, phy, mmd, MDIO_MMDREG_CTRL1,
249                                        MDIO_MMDREG_CTRL1_LPOWER_LBN, lpower);
250         }
251 }
252
253 void mdio_clause45_set_mmds_lpower(struct efx_nic *efx,
254                                    int low_power, unsigned int mmd_mask)
255 {
256         int mmd = 0;
257         mmd_mask &= ~MDIO_MMDREG_DEVS_AN;
258         while (mmd_mask) {
259                 if (mmd_mask & 1)
260                         mdio_clause45_set_mmd_lpower(efx, low_power, mmd);
261                 mmd_mask = (mmd_mask >> 1);
262                 mmd++;
263         }
264 }
265
266 static u32 mdio_clause45_get_an(struct efx_nic *efx, u16 addr, u32 xnp)
267 {
268         int phy_id = efx->mii.phy_id;
269         u32 result = 0;
270         int reg;
271
272         reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN, addr);
273         if (reg & ADVERTISE_10HALF)
274                 result |= ADVERTISED_10baseT_Half;
275         if (reg & ADVERTISE_10FULL)
276                 result |= ADVERTISED_10baseT_Full;
277         if (reg & ADVERTISE_100HALF)
278                 result |= ADVERTISED_100baseT_Half;
279         if (reg & ADVERTISE_100FULL)
280                 result |= ADVERTISED_100baseT_Full;
281         if (reg & LPA_RESV)
282                 result |= xnp;
283
284         return result;
285 }
286
287 /**
288  * mdio_clause45_get_settings - Read (some of) the PHY settings over MDIO.
289  * @efx:                Efx NIC
290  * @ecmd:               Buffer for settings
291  *
292  * On return the 'port', 'speed', 'supported' and 'advertising' fields of
293  * ecmd have been filled out.
294  */
295 void mdio_clause45_get_settings(struct efx_nic *efx,
296                                 struct ethtool_cmd *ecmd)
297 {
298         mdio_clause45_get_settings_ext(efx, ecmd, 0, 0);
299 }
300
301 /**
302  * mdio_clause45_get_settings_ext - Read (some of) the PHY settings over MDIO.
303  * @efx:                Efx NIC
304  * @ecmd:               Buffer for settings
305  * @xnp:                Advertised Extended Next Page state
306  * @xnp_lpa:            Link Partner's advertised XNP state
307  *
308  * On return the 'port', 'speed', 'supported' and 'advertising' fields of
309  * ecmd have been filled out.
310  */
311 void mdio_clause45_get_settings_ext(struct efx_nic *efx,
312                                     struct ethtool_cmd *ecmd,
313                                     u32 xnp, u32 xnp_lpa)
314 {
315         int phy_id = efx->mii.phy_id;
316         int reg;
317
318         ecmd->transceiver = XCVR_INTERNAL;
319         ecmd->phy_address = phy_id;
320
321         reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
322                                  MDIO_MMDREG_CTRL2);
323         switch (reg & MDIO_PMAPMD_CTRL2_TYPE_MASK) {
324         case MDIO_PMAPMD_CTRL2_10G_BT:
325         case MDIO_PMAPMD_CTRL2_1G_BT:
326         case MDIO_PMAPMD_CTRL2_100_BT:
327         case MDIO_PMAPMD_CTRL2_10_BT:
328                 ecmd->port = PORT_TP;
329                 ecmd->supported = SUPPORTED_TP;
330                 reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
331                                          MDIO_MMDREG_SPEED);
332                 if (reg & (1 << MDIO_MMDREG_SPEED_10G_LBN))
333                         ecmd->supported |= SUPPORTED_10000baseT_Full;
334                 if (reg & (1 << MDIO_MMDREG_SPEED_1000M_LBN))
335                         ecmd->supported |= (SUPPORTED_1000baseT_Full |
336                                             SUPPORTED_1000baseT_Half);
337                 if (reg & (1 << MDIO_MMDREG_SPEED_100M_LBN))
338                         ecmd->supported |= (SUPPORTED_100baseT_Full |
339                                             SUPPORTED_100baseT_Half);
340                 if (reg & (1 << MDIO_MMDREG_SPEED_10M_LBN))
341                         ecmd->supported |= (SUPPORTED_10baseT_Full |
342                                             SUPPORTED_10baseT_Half);
343                 ecmd->advertising = ADVERTISED_TP;
344                 break;
345
346         /* We represent CX4 as fibre in the absence of anything better */
347         case MDIO_PMAPMD_CTRL2_10G_CX4:
348         /* All the other defined modes are flavours of optical */
349         default:
350                 ecmd->port = PORT_FIBRE;
351                 ecmd->supported = SUPPORTED_FIBRE;
352                 ecmd->advertising = ADVERTISED_FIBRE;
353                 break;
354         }
355
356         if (efx->phy_op->mmds & DEV_PRESENT_BIT(MDIO_MMD_AN)) {
357                 ecmd->supported |= SUPPORTED_Autoneg;
358                 reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
359                                          MDIO_MMDREG_CTRL1);
360                 if (reg & BMCR_ANENABLE) {
361                         ecmd->autoneg = AUTONEG_ENABLE;
362                         ecmd->advertising |=
363                                 ADVERTISED_Autoneg |
364                                 mdio_clause45_get_an(efx,
365                                                      MDIO_AN_ADVERTISE, xnp);
366                 } else
367                         ecmd->autoneg = AUTONEG_DISABLE;
368         } else
369                 ecmd->autoneg = AUTONEG_DISABLE;
370
371         if (ecmd->autoneg) {
372                 /* If AN is complete, report best common mode,
373                  * otherwise report best advertised mode. */
374                 u32 common = ecmd->advertising;
375                 if (mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
376                                        MDIO_MMDREG_STAT1) &
377                     (1 << MDIO_AN_STATUS_AN_DONE_LBN)) {
378                         common &= mdio_clause45_get_an(efx, MDIO_AN_LPA,
379                                                        xnp_lpa);
380                 }
381                 if (common & ADVERTISED_10000baseT_Full) {
382                         ecmd->speed = SPEED_10000;
383                         ecmd->duplex = DUPLEX_FULL;
384                 } else if (common & (ADVERTISED_1000baseT_Full |
385                                      ADVERTISED_1000baseT_Half)) {
386                         ecmd->speed = SPEED_1000;
387                         ecmd->duplex = !!(common & ADVERTISED_1000baseT_Full);
388                 } else if (common & (ADVERTISED_100baseT_Full |
389                                      ADVERTISED_100baseT_Half)) {
390                         ecmd->speed = SPEED_100;
391                         ecmd->duplex = !!(common & ADVERTISED_100baseT_Full);
392                 } else {
393                         ecmd->speed = SPEED_10;
394                         ecmd->duplex = !!(common & ADVERTISED_10baseT_Full);
395                 }
396         } else {
397                 /* Report forced settings */
398                 reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
399                                          MDIO_MMDREG_CTRL1);
400                 ecmd->speed = (((reg & BMCR_SPEED1000) ? 100 : 1) *
401                                ((reg & BMCR_SPEED100) ? 100 : 10));
402                 ecmd->duplex = (reg & BMCR_FULLDPLX ||
403                                 ecmd->speed == SPEED_10000);
404         }
405 }
406
407 /**
408  * mdio_clause45_set_settings - Set (some of) the PHY settings over MDIO.
409  * @efx:                Efx NIC
410  * @ecmd:               New settings
411  */
412 int mdio_clause45_set_settings(struct efx_nic *efx,
413                                struct ethtool_cmd *ecmd)
414 {
415         int phy_id = efx->mii.phy_id;
416         struct ethtool_cmd prev;
417         u32 required;
418         int ctrl1_bits, reg;
419
420         efx->phy_op->get_settings(efx, &prev);
421
422         if (ecmd->advertising == prev.advertising &&
423             ecmd->speed == prev.speed &&
424             ecmd->duplex == prev.duplex &&
425             ecmd->port == prev.port &&
426             ecmd->autoneg == prev.autoneg)
427                 return 0;
428
429         /* We can only change these settings for -T PHYs */
430         if (prev.port != PORT_TP || ecmd->port != PORT_TP)
431                 return -EINVAL;
432
433         /* Check that PHY supports these settings and work out the
434          * basic control bits */
435         if (ecmd->duplex) {
436                 switch (ecmd->speed) {
437                 case SPEED_10:
438                         ctrl1_bits = BMCR_FULLDPLX;
439                         required = SUPPORTED_10baseT_Full;
440                         break;
441                 case SPEED_100:
442                         ctrl1_bits = BMCR_SPEED100 | BMCR_FULLDPLX;
443                         required = SUPPORTED_100baseT_Full;
444                         break;
445                 case SPEED_1000:
446                         ctrl1_bits = BMCR_SPEED1000 | BMCR_FULLDPLX;
447                         required = SUPPORTED_1000baseT_Full;
448                         break;
449                 case SPEED_10000:
450                         ctrl1_bits = (BMCR_SPEED1000 | BMCR_SPEED100 |
451                                       BMCR_FULLDPLX);
452                         required = SUPPORTED_10000baseT_Full;
453                         break;
454                 default:
455                         return -EINVAL;
456                 }
457         } else {
458                 switch (ecmd->speed) {
459                 case SPEED_10:
460                         ctrl1_bits = 0;
461                         required = SUPPORTED_10baseT_Half;
462                         break;
463                 case SPEED_100:
464                         ctrl1_bits = BMCR_SPEED100;
465                         required = SUPPORTED_100baseT_Half;
466                         break;
467                 case SPEED_1000:
468                         ctrl1_bits = BMCR_SPEED1000;
469                         required = SUPPORTED_1000baseT_Half;
470                         break;
471                 default:
472                         return -EINVAL;
473                 }
474         }
475         if (ecmd->autoneg)
476                 required |= SUPPORTED_Autoneg;
477         required |= ecmd->advertising;
478         if (required & ~prev.supported)
479                 return -EINVAL;
480
481         /* Set the basic control bits */
482         reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
483                                  MDIO_MMDREG_CTRL1);
484         reg &= ~(BMCR_SPEED1000 | BMCR_SPEED100 | BMCR_FULLDPLX | 0x003c);
485         reg |= ctrl1_bits;
486         mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD, MDIO_MMDREG_CTRL1,
487                             reg);
488
489         /* Set the AN registers */
490         if (ecmd->autoneg != prev.autoneg ||
491             ecmd->advertising != prev.advertising) {
492                 bool xnp = false;
493
494                 if (efx->phy_op->set_xnp_advertise)
495                         xnp = efx->phy_op->set_xnp_advertise(efx,
496                                                              ecmd->advertising);
497
498                 if (ecmd->autoneg) {
499                         reg = 0;
500                         if (ecmd->advertising & ADVERTISED_10baseT_Half)
501                                 reg |= ADVERTISE_10HALF;
502                         if (ecmd->advertising & ADVERTISED_10baseT_Full)
503                                 reg |= ADVERTISE_10FULL;
504                         if (ecmd->advertising & ADVERTISED_100baseT_Half)
505                                 reg |= ADVERTISE_100HALF;
506                         if (ecmd->advertising & ADVERTISED_100baseT_Full)
507                                 reg |= ADVERTISE_100FULL;
508                         if (xnp)
509                                 reg |= ADVERTISE_RESV;
510                         mdio_clause45_write(efx, phy_id, MDIO_MMD_AN,
511                                             MDIO_AN_ADVERTISE, reg);
512                 }
513
514                 reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
515                                          MDIO_MMDREG_CTRL1);
516                 if (ecmd->autoneg)
517                         reg |= BMCR_ANENABLE | BMCR_ANRESTART;
518                 else
519                         reg &= ~BMCR_ANENABLE;
520                 if (xnp)
521                         reg |= 1 << MDIO_AN_CTRL_XNP_LBN;
522                 else
523                         reg &= ~(1 << MDIO_AN_CTRL_XNP_LBN);
524                 mdio_clause45_write(efx, phy_id, MDIO_MMD_AN,
525                                     MDIO_MMDREG_CTRL1, reg);
526         }
527
528         return 0;
529 }
530
531 void mdio_clause45_set_pause(struct efx_nic *efx)
532 {
533         int phy_id = efx->mii.phy_id;
534         int reg;
535
536         if (efx->phy_op->mmds & DEV_PRESENT_BIT(MDIO_MMD_AN)) {
537                 /* Set pause capability advertising */
538                 reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
539                                          MDIO_AN_ADVERTISE);
540                 reg &= ~(ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
541                 reg |= efx_fc_advertise(efx->wanted_fc);
542                 mdio_clause45_write(efx, phy_id, MDIO_MMD_AN,
543                                     MDIO_AN_ADVERTISE, reg);
544
545                 /* Restart auto-negotiation */
546                 reg = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN,
547                                          MDIO_MMDREG_CTRL1);
548                 if (reg & BMCR_ANENABLE) {
549                         reg |= BMCR_ANRESTART;
550                         mdio_clause45_write(efx, phy_id, MDIO_MMD_AN,
551                                             MDIO_MMDREG_CTRL1, reg);
552                 }
553         }
554 }
555
556 enum efx_fc_type mdio_clause45_get_pause(struct efx_nic *efx)
557 {
558         int phy_id = efx->mii.phy_id;
559         int lpa;
560
561         if (!(efx->phy_op->mmds & DEV_PRESENT_BIT(MDIO_MMD_AN)))
562                 return efx->wanted_fc;
563         lpa = mdio_clause45_read(efx, phy_id, MDIO_MMD_AN, MDIO_AN_LPA);
564         return efx_fc_resolve(efx->wanted_fc, lpa);
565 }
566
567 void mdio_clause45_set_flag(struct efx_nic *efx, u8 prt, u8 dev,
568                             u16 addr, int bit, bool sense)
569 {
570         int old_val = mdio_clause45_read(efx, prt, dev, addr);
571         int new_val;
572
573         if (sense)
574                 new_val = old_val | (1 << bit);
575         else
576                 new_val = old_val & ~(1 << bit);
577         if (old_val != new_val)
578                 mdio_clause45_write(efx, prt, dev, addr, new_val);
579 }