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