b355872de6c20723b43a76a28af077a1163f3143
[linux-2.6.git] / 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 "workarounds.h"
18
19 unsigned efx_mdio_id_oui(u32 id)
20 {
21         unsigned oui = 0;
22         int i;
23
24         /* The bits of the OUI are designated a..x, with a=0 and b variable.
25          * In the id register c is the MSB but the OUI is conventionally
26          * written as bytes h..a, p..i, x..q.  Reorder the bits accordingly. */
27         for (i = 0; i < 22; ++i)
28                 if (id & (1 << (i + 10)))
29                         oui |= 1 << (i ^ 7);
30
31         return oui;
32 }
33
34 int efx_mdio_reset_mmd(struct efx_nic *port, int mmd,
35                             int spins, int spintime)
36 {
37         u32 ctrl;
38
39         /* Catch callers passing values in the wrong units (or just silly) */
40         EFX_BUG_ON_PARANOID(spins * spintime >= 5000);
41
42         efx_mdio_write(port, mmd, MDIO_CTRL1, MDIO_CTRL1_RESET);
43         /* Wait for the reset bit to clear. */
44         do {
45                 msleep(spintime);
46                 ctrl = efx_mdio_read(port, mmd, MDIO_CTRL1);
47                 spins--;
48
49         } while (spins && (ctrl & MDIO_CTRL1_RESET));
50
51         return spins ? spins : -ETIMEDOUT;
52 }
53
54 static int efx_mdio_check_mmd(struct efx_nic *efx, int mmd, int fault_fatal)
55 {
56         int status;
57
58         if (LOOPBACK_INTERNAL(efx))
59                 return 0;
60
61         if (mmd != MDIO_MMD_AN) {
62                 /* Read MMD STATUS2 to check it is responding. */
63                 status = efx_mdio_read(efx, mmd, MDIO_STAT2);
64                 if ((status & MDIO_STAT2_DEVPRST) != MDIO_STAT2_DEVPRST_VAL) {
65                         EFX_ERR(efx, "PHY MMD %d not responding.\n", mmd);
66                         return -EIO;
67                 }
68         }
69
70         /* Read MMD STATUS 1 to check for fault. */
71         status = efx_mdio_read(efx, mmd, MDIO_STAT1);
72         if (status & MDIO_STAT1_FAULT) {
73                 if (fault_fatal) {
74                         EFX_ERR(efx, "PHY MMD %d reporting fatal"
75                                 " fault: status %x\n", mmd, status);
76                         return -EIO;
77                 } else {
78                         EFX_LOG(efx, "PHY MMD %d reporting status"
79                                 " %x (expected)\n", mmd, status);
80                 }
81         }
82         return 0;
83 }
84
85 /* This ought to be ridiculous overkill. We expect it to fail rarely */
86 #define MDIO45_RESET_TIME       1000 /* ms */
87 #define MDIO45_RESET_ITERS      100
88
89 int efx_mdio_wait_reset_mmds(struct efx_nic *efx, unsigned int mmd_mask)
90 {
91         const int spintime = MDIO45_RESET_TIME / MDIO45_RESET_ITERS;
92         int tries = MDIO45_RESET_ITERS;
93         int rc = 0;
94         int in_reset;
95
96         while (tries) {
97                 int mask = mmd_mask;
98                 int mmd = 0;
99                 int stat;
100                 in_reset = 0;
101                 while (mask) {
102                         if (mask & 1) {
103                                 stat = efx_mdio_read(efx, mmd, MDIO_CTRL1);
104                                 if (stat < 0) {
105                                         EFX_ERR(efx, "failed to read status of"
106                                                 " MMD %d\n", mmd);
107                                         return -EIO;
108                                 }
109                                 if (stat & MDIO_CTRL1_RESET)
110                                         in_reset |= (1 << mmd);
111                         }
112                         mask = mask >> 1;
113                         mmd++;
114                 }
115                 if (!in_reset)
116                         break;
117                 tries--;
118                 msleep(spintime);
119         }
120         if (in_reset != 0) {
121                 EFX_ERR(efx, "not all MMDs came out of reset in time."
122                         " MMDs still in reset: %x\n", in_reset);
123                 rc = -ETIMEDOUT;
124         }
125         return rc;
126 }
127
128 int efx_mdio_check_mmds(struct efx_nic *efx,
129                         unsigned int mmd_mask, unsigned int fatal_mask)
130 {
131         int mmd = 0, probe_mmd, devs1, devs2;
132         u32 devices;
133
134         /* Historically we have probed the PHYXS to find out what devices are
135          * present,but that doesn't work so well if the PHYXS isn't expected
136          * to exist, if so just find the first item in the list supplied. */
137         probe_mmd = (mmd_mask & MDIO_DEVS_PHYXS) ? MDIO_MMD_PHYXS :
138             __ffs(mmd_mask);
139
140         /* Check all the expected MMDs are present */
141         devs1 = efx_mdio_read(efx, probe_mmd, MDIO_DEVS1);
142         devs2 = efx_mdio_read(efx, probe_mmd, MDIO_DEVS2);
143         if (devs1 < 0 || devs2 < 0) {
144                 EFX_ERR(efx, "failed to read devices present\n");
145                 return -EIO;
146         }
147         devices = devs1 | (devs2 << 16);
148         if ((devices & mmd_mask) != mmd_mask) {
149                 EFX_ERR(efx, "required MMDs not present: got %x, "
150                         "wanted %x\n", devices, mmd_mask);
151                 return -ENODEV;
152         }
153         EFX_TRACE(efx, "Devices present: %x\n", devices);
154
155         /* Check all required MMDs are responding and happy. */
156         while (mmd_mask) {
157                 if (mmd_mask & 1) {
158                         int fault_fatal = fatal_mask & 1;
159                         if (efx_mdio_check_mmd(efx, mmd, fault_fatal))
160                                 return -EIO;
161                 }
162                 mmd_mask = mmd_mask >> 1;
163                 fatal_mask = fatal_mask >> 1;
164                 mmd++;
165         }
166
167         return 0;
168 }
169
170 bool efx_mdio_links_ok(struct efx_nic *efx, unsigned int mmd_mask)
171 {
172         /* If the port is in loopback, then we should only consider a subset
173          * of mmd's */
174         if (LOOPBACK_INTERNAL(efx))
175                 return true;
176         else if (efx->loopback_mode == LOOPBACK_NETWORK)
177                 return false;
178         else if (efx_phy_mode_disabled(efx->phy_mode))
179                 return false;
180         else if (efx->loopback_mode == LOOPBACK_PHYXS)
181                 mmd_mask &= ~(MDIO_DEVS_PHYXS |
182                               MDIO_DEVS_PCS |
183                               MDIO_DEVS_PMAPMD |
184                               MDIO_DEVS_AN);
185         else if (efx->loopback_mode == LOOPBACK_PCS)
186                 mmd_mask &= ~(MDIO_DEVS_PCS |
187                               MDIO_DEVS_PMAPMD |
188                               MDIO_DEVS_AN);
189         else if (efx->loopback_mode == LOOPBACK_PMAPMD)
190                 mmd_mask &= ~(MDIO_DEVS_PMAPMD |
191                               MDIO_DEVS_AN);
192
193         return mdio45_links_ok(&efx->mdio, mmd_mask);
194 }
195
196 void efx_mdio_transmit_disable(struct efx_nic *efx)
197 {
198         efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD,
199                           MDIO_PMA_TXDIS, MDIO_PMD_TXDIS_GLOBAL,
200                           efx->phy_mode & PHY_MODE_TX_DISABLED);
201 }
202
203 void efx_mdio_phy_reconfigure(struct efx_nic *efx)
204 {
205         efx_mdio_set_flag(efx, MDIO_MMD_PMAPMD,
206                           MDIO_CTRL1, MDIO_PMA_CTRL1_LOOPBACK,
207                           efx->loopback_mode == LOOPBACK_PMAPMD);
208         efx_mdio_set_flag(efx, MDIO_MMD_PCS,
209                           MDIO_CTRL1, MDIO_PCS_CTRL1_LOOPBACK,
210                           efx->loopback_mode == LOOPBACK_PCS);
211         efx_mdio_set_flag(efx, MDIO_MMD_PHYXS,
212                           MDIO_CTRL1, MDIO_PHYXS_CTRL1_LOOPBACK,
213                           efx->loopback_mode == LOOPBACK_NETWORK);
214 }
215
216 static void efx_mdio_set_mmd_lpower(struct efx_nic *efx,
217                                     int lpower, int mmd)
218 {
219         int stat = efx_mdio_read(efx, mmd, MDIO_STAT1);
220
221         EFX_TRACE(efx, "Setting low power mode for MMD %d to %d\n",
222                   mmd, lpower);
223
224         if (stat & MDIO_STAT1_LPOWERABLE) {
225                 efx_mdio_set_flag(efx, mmd, MDIO_CTRL1,
226                                   MDIO_CTRL1_LPOWER, lpower);
227         }
228 }
229
230 void efx_mdio_set_mmds_lpower(struct efx_nic *efx,
231                               int low_power, unsigned int mmd_mask)
232 {
233         int mmd = 0;
234         mmd_mask &= ~MDIO_DEVS_AN;
235         while (mmd_mask) {
236                 if (mmd_mask & 1)
237                         efx_mdio_set_mmd_lpower(efx, low_power, mmd);
238                 mmd_mask = (mmd_mask >> 1);
239                 mmd++;
240         }
241 }
242
243 /**
244  * efx_mdio_set_settings - Set (some of) the PHY settings over MDIO.
245  * @efx:                Efx NIC
246  * @ecmd:               New settings
247  */
248 int efx_mdio_set_settings(struct efx_nic *efx, struct ethtool_cmd *ecmd)
249 {
250         struct ethtool_cmd prev;
251         u32 required;
252         int reg;
253
254         efx->phy_op->get_settings(efx, &prev);
255
256         if (ecmd->advertising == prev.advertising &&
257             ecmd->speed == prev.speed &&
258             ecmd->duplex == prev.duplex &&
259             ecmd->port == prev.port &&
260             ecmd->autoneg == prev.autoneg)
261                 return 0;
262
263         /* We can only change these settings for -T PHYs */
264         if (prev.port != PORT_TP || ecmd->port != PORT_TP)
265                 return -EINVAL;
266
267         /* Check that PHY supports these settings */
268         if (ecmd->autoneg) {
269                 required = SUPPORTED_Autoneg;
270         } else if (ecmd->duplex) {
271                 switch (ecmd->speed) {
272                 case SPEED_10:  required = SUPPORTED_10baseT_Full;  break;
273                 case SPEED_100: required = SUPPORTED_100baseT_Full; break;
274                 default:        return -EINVAL;
275                 }
276         } else {
277                 switch (ecmd->speed) {
278                 case SPEED_10:  required = SUPPORTED_10baseT_Half;  break;
279                 case SPEED_100: required = SUPPORTED_100baseT_Half; break;
280                 default:        return -EINVAL;
281                 }
282         }
283         required |= ecmd->advertising;
284         if (required & ~prev.supported)
285                 return -EINVAL;
286
287         if (ecmd->autoneg) {
288                 bool xnp = (ecmd->advertising & ADVERTISED_10000baseT_Full
289                             || EFX_WORKAROUND_13204(efx));
290
291                 /* Set up the base page */
292                 reg = ADVERTISE_CSMA;
293                 if (ecmd->advertising & ADVERTISED_10baseT_Half)
294                         reg |= ADVERTISE_10HALF;
295                 if (ecmd->advertising & ADVERTISED_10baseT_Full)
296                         reg |= ADVERTISE_10FULL;
297                 if (ecmd->advertising & ADVERTISED_100baseT_Half)
298                         reg |= ADVERTISE_100HALF;
299                 if (ecmd->advertising & ADVERTISED_100baseT_Full)
300                         reg |= ADVERTISE_100FULL;
301                 if (xnp)
302                         reg |= ADVERTISE_RESV;
303                 else if (ecmd->advertising & (ADVERTISED_1000baseT_Half |
304                                               ADVERTISED_1000baseT_Full))
305                         reg |= ADVERTISE_NPAGE;
306                 reg |= mii_advertise_flowctrl(efx->wanted_fc);
307                 efx_mdio_write(efx, MDIO_MMD_AN, MDIO_AN_ADVERTISE, reg);
308
309                 /* Set up the (extended) next page if necessary */
310                 if (efx->phy_op->set_npage_adv)
311                         efx->phy_op->set_npage_adv(efx, ecmd->advertising);
312
313                 /* Enable and restart AN */
314                 reg = efx_mdio_read(efx, MDIO_MMD_AN, MDIO_CTRL1);
315                 reg |= MDIO_AN_CTRL1_ENABLE;
316                 if (!(EFX_WORKAROUND_15195(efx) &&
317                       LOOPBACK_MASK(efx) & efx->phy_op->loopbacks))
318                         reg |= MDIO_AN_CTRL1_RESTART;
319                 if (xnp)
320                         reg |= MDIO_AN_CTRL1_XNP;
321                 else
322                         reg &= ~MDIO_AN_CTRL1_XNP;
323                 efx_mdio_write(efx, MDIO_MMD_AN, MDIO_CTRL1, reg);
324         } else {
325                 /* Disable AN */
326                 efx_mdio_set_flag(efx, MDIO_MMD_AN, MDIO_CTRL1,
327                                   MDIO_AN_CTRL1_ENABLE, false);
328
329                 /* Set the basic control bits */
330                 reg = efx_mdio_read(efx, MDIO_MMD_PMAPMD, MDIO_CTRL1);
331                 reg &= ~(MDIO_CTRL1_SPEEDSEL | MDIO_CTRL1_FULLDPLX);
332                 if (ecmd->speed == SPEED_100)
333                         reg |= MDIO_PMA_CTRL1_SPEED100;
334                 if (ecmd->duplex)
335                         reg |= MDIO_CTRL1_FULLDPLX;
336                 efx_mdio_write(efx, MDIO_MMD_PMAPMD, MDIO_CTRL1, reg);
337         }
338
339         return 0;
340 }
341
342 enum efx_fc_type efx_mdio_get_pause(struct efx_nic *efx)
343 {
344         int lpa;
345
346         if (!(efx->phy_op->mmds & MDIO_DEVS_AN))
347                 return efx->wanted_fc;
348         lpa = efx_mdio_read(efx, MDIO_MMD_AN, MDIO_AN_LPA);
349         return efx_fc_resolve(efx->wanted_fc, lpa);
350 }