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         /* Read MMD STATUS2 to check it is responding. */
  51         status = mdio_clause45_read(efx, phy_id, mmd, MDIO_MMDREG_STAT2);
  52         if (((status >> MDIO_MMDREG_STAT2_PRESENT_LBN) &
  53              ((1 << MDIO_MMDREG_STAT2_PRESENT_WIDTH) - 1)) !=
  54             MDIO_MMDREG_STAT2_PRESENT_VAL) {
  55                 EFX_ERR(efx, "PHY MMD %d not responding.\n", mmd);
  56                 return -EIO;
  57         }
  58
  59         /* Read MMD STATUS 1 to check for fault. */
  60         status = mdio_clause45_read(efx, phy_id, mmd, MDIO_MMDREG_STAT1);
  61         if ((status & (1 << MDIO_MMDREG_STAT1_FAULT_LBN)) != 0) {
  62                 if (fault_fatal) {
  63                         EFX_ERR(efx, "PHY MMD %d reporting fatal"
  64                                 " fault: status %x\n", mmd, status);
  65                         return -EIO;
  66                 } else {
  67                         EFX_LOG(efx, "PHY MMD %d reporting status"
  68                                 " %x (expected)\n", mmd, status);
  69                 }
  70         }
  71         return 0;
  72 }
  73
  74 /* This ought to be ridiculous overkill. We expect it to fail rarely */
  75 #define MDIO45_RESET_TIME       1000 /* ms */
  76 #define MDIO45_RESET_ITERS      100
  77
  78 int mdio_clause45_wait_reset_mmds(struct efx_nic *efx,
  79                                   unsigned int mmd_mask)
  80 {
  81         const int spintime = MDIO45_RESET_TIME / MDIO45_RESET_ITERS;
  82         int tries = MDIO45_RESET_ITERS;
  83         int rc = 0;
  84         int in_reset;
  85
  86         while (tries) {
  87                 int mask = mmd_mask;
  88                 int mmd = 0;
  89                 int stat;
  90                 in_reset = 0;
  91                 while (mask) {
  92                         if (mask & 1) {
  93                                 stat = mdio_clause45_read(efx,
  94                                                           efx->mii.phy_id,
  95                                                           mmd,
  96                                                           MDIO_MMDREG_CTRL1);
  97                                 if (stat < 0) {
  98                                         EFX_ERR(efx, "failed to read status of"
  99                                                 " MMD %d\n", mmd);
 100                                         return -EIO;
 101                                 }
 102                                 if (stat & (1 << MDIO_MMDREG_CTRL1_RESET_LBN))
 103                                         in_reset |= (1 << mmd);
 104                         }
 105                         mask = mask >> 1;
 106                         mmd++;
 107                 }
 108                 if (!in_reset)
 109                         break;
 110                 tries--;
 111                 msleep(spintime);
 112         }
 113         if (in_reset != 0) {
 114                 EFX_ERR(efx, "not all MMDs came out of reset in time."
 115                         " MMDs still in reset: %x\n", in_reset);
 116                 rc = -ETIMEDOUT;
 117         }
 118         return rc;
 119 }
 120
 121 int mdio_clause45_check_mmds(struct efx_nic *efx,
 122                              unsigned int mmd_mask, unsigned int fatal_mask)
 123 {
 124         int devices, mmd = 0;
 125         int probe_mmd;
 126
 127         /* Historically we have probed the PHYXS to find out what devices are
 128          * present,but that doesn't work so well if the PHYXS isn't expected
 129          * to exist, if so just find the first item in the list supplied. */
 130         probe_mmd = (mmd_mask & MDIO_MMDREG_DEVS0_PHYXS) ? MDIO_MMD_PHYXS :
 131             __ffs(mmd_mask);
 132         devices = mdio_clause45_read(efx, efx->mii.phy_id,
 133                                      probe_mmd, MDIO_MMDREG_DEVS0);
 134
 135         /* Check all the expected MMDs are present */
 136         if (devices < 0) {
 137                 EFX_ERR(efx, "failed to read devices present\n");
 138                 return -EIO;
 139         }
 140         if ((devices & mmd_mask) != mmd_mask) {
 141                 EFX_ERR(efx, "required MMDs not present: got %x, "
 142                         "wanted %x\n", devices, mmd_mask);
 143                 return -ENODEV;
 144         }
 145         EFX_TRACE(efx, "Devices present: %x\n", devices);
 146
 147         /* Check all required MMDs are responding and happy. */
 148         while (mmd_mask) {
 149                 if (mmd_mask & 1) {
 150                         int fault_fatal = fatal_mask & 1;
 151                         if (mdio_clause45_check_mmd(efx, mmd, fault_fatal))
 152                                 return -EIO;
 153                 }
 154                 mmd_mask = mmd_mask >> 1;
 155                 fatal_mask = fatal_mask >> 1;
 156                 mmd++;
 157         }
 158
 159         return 0;
 160 }
 161
 162 bool mdio_clause45_links_ok(struct efx_nic *efx, unsigned int mmd_mask)
 163 {
 164         int phy_id = efx->mii.phy_id;
 165         int status;
 166         bool ok = true;
 167         int mmd = 0;
 168
 169         /* If the port is in loopback, then we should only consider a subset
 170          * of mmd's */
 171         if (LOOPBACK_INTERNAL(efx))
 172                 return true;
 173         else if (efx->loopback_mode == LOOPBACK_NETWORK)
 174                 return false;
 175         else if (efx->loopback_mode == LOOPBACK_PHYXS)
 176                 mmd_mask &= ~(MDIO_MMDREG_DEVS0_PHYXS |
 177                               MDIO_MMDREG_DEVS0_PCS |
 178                               MDIO_MMDREG_DEVS0_PMAPMD);
 179         else if (efx->loopback_mode == LOOPBACK_PCS)
 180                 mmd_mask &= ~(MDIO_MMDREG_DEVS0_PCS |
 181                               MDIO_MMDREG_DEVS0_PMAPMD);
 182         else if (efx->loopback_mode == LOOPBACK_PMAPMD)
 183                 mmd_mask &= ~MDIO_MMDREG_DEVS0_PMAPMD;
 184
 185         while (mmd_mask) {
 186                 if (mmd_mask & 1) {
 187                         /* Double reads because link state is latched, and a
 188                          * read moves the current state into the register */
 189                         status = mdio_clause45_read(efx, phy_id,
 190                                                     mmd, MDIO_MMDREG_STAT1);
 191                         status = mdio_clause45_read(efx, phy_id,
 192                                                     mmd, MDIO_MMDREG_STAT1);
 193
 194                         ok = ok && (status & (1 << MDIO_MMDREG_STAT1_LINK_LBN));
 195                 }
 196                 mmd_mask = (mmd_mask >> 1);
 197                 mmd++;
 198         }
 199         return ok;
 200 }
 201
 202 void mdio_clause45_transmit_disable(struct efx_nic *efx)
 203 {
 204         int phy_id = efx->mii.phy_id;
 205         int ctrl1, ctrl2;
 206
 207         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
 208                                            MDIO_MMDREG_TXDIS);
 209         if (efx->tx_disabled)
 210                 ctrl2 |= (1 << MDIO_MMDREG_TXDIS_GLOBAL_LBN);
 211         else
 212                 ctrl1 &= ~(1 << MDIO_MMDREG_TXDIS_GLOBAL_LBN);
 213         if (ctrl1 != ctrl2)
 214                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD,
 215                                     MDIO_MMDREG_TXDIS, ctrl2);
 216 }
 217
 218 void mdio_clause45_phy_reconfigure(struct efx_nic *efx)
 219 {
 220         int phy_id = efx->mii.phy_id;
 221         int ctrl1, ctrl2;
 222
 223         /* Handle (with debouncing) PMA/PMD loopback */
 224         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
 225                                            MDIO_MMDREG_CTRL1);
 226
 227         if (efx->loopback_mode == LOOPBACK_PMAPMD)
 228                 ctrl2 |= (1 << MDIO_PMAPMD_CTRL1_LBACK_LBN);
 229         else
 230                 ctrl2 &= ~(1 << MDIO_PMAPMD_CTRL1_LBACK_LBN);
 231
 232         if (ctrl1 != ctrl2)
 233                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD,
 234                                     MDIO_MMDREG_CTRL1, ctrl2);
 235
 236         /* Handle (with debouncing) PCS loopback */
 237         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PCS,
 238                                            MDIO_MMDREG_CTRL1);
 239         if (efx->loopback_mode == LOOPBACK_PCS)
 240                 ctrl2 |= (1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 241         else
 242                 ctrl2 &= ~(1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 243
 244         if (ctrl1 != ctrl2)
 245                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PCS,
 246                                     MDIO_MMDREG_CTRL1, ctrl2);
 247
 248         /* Handle (with debouncing) PHYXS network loopback */
 249         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PHYXS,
 250                                            MDIO_MMDREG_CTRL1);
 251         if (efx->loopback_mode == LOOPBACK_NETWORK)
 252                 ctrl2 |= (1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 253         else
 254                 ctrl2 &= ~(1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 255
 256         if (ctrl1 != ctrl2)
 257                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PHYXS,
 258                                     MDIO_MMDREG_CTRL1, ctrl2);
 259 }
 260
 261 /**
 262  * mdio_clause45_get_settings - Read (some of) the PHY settings over MDIO.
 263  * @efx:                Efx NIC
 264  * @ecmd:               Buffer for settings
 265  *
 266  * On return the 'port', 'speed', 'supported' and 'advertising' fields of
 267  * ecmd have been filled out based on the PMA type.
 268  */
 269 void mdio_clause45_get_settings(struct efx_nic *efx,
 270                                 struct ethtool_cmd *ecmd)
 271 {
 272         int pma_type;
 273
 274         /* If no PMA is present we are presumably talking something XAUI-ish
 275          * like CX4. Which we report as FIBRE (see below) */
 276         if ((efx->phy_op->mmds & DEV_PRESENT_BIT(MDIO_MMD_PMAPMD)) == 0) {
 277                 ecmd->speed = SPEED_10000;
 278                 ecmd->port = PORT_FIBRE;
 279                 ecmd->supported = SUPPORTED_FIBRE;
 280                 ecmd->advertising = ADVERTISED_FIBRE;
 281                 return;
 282         }
 283
 284         pma_type = mdio_clause45_read(efx, efx->mii.phy_id,
 285                                       MDIO_MMD_PMAPMD, MDIO_MMDREG_CTRL2);
 286         pma_type &= MDIO_PMAPMD_CTRL2_TYPE_MASK;
 287
 288         switch (pma_type) {
 289                 /* We represent CX4 as fibre in the absence of anything
 290                    better. */
 291         case MDIO_PMAPMD_CTRL2_10G_CX4:
 292                 ecmd->speed = SPEED_10000;
 293                 ecmd->port = PORT_FIBRE;
 294                 ecmd->supported = SUPPORTED_FIBRE;
 295                 ecmd->advertising = ADVERTISED_FIBRE;
 296                 break;
 297                 /* 10G Base-T */
 298         case MDIO_PMAPMD_CTRL2_10G_BT:
 299                 ecmd->speed = SPEED_10000;
 300                 ecmd->port = PORT_TP;
 301                 ecmd->supported = SUPPORTED_TP | SUPPORTED_10000baseT_Full;
 302                 ecmd->advertising = (ADVERTISED_FIBRE
 303                                      | ADVERTISED_10000baseT_Full);
 304                 break;
 305         case MDIO_PMAPMD_CTRL2_1G_BT:
 306                 ecmd->speed = SPEED_1000;
 307                 ecmd->port = PORT_TP;
 308                 ecmd->supported = SUPPORTED_TP | SUPPORTED_1000baseT_Full;
 309                 ecmd->advertising = (ADVERTISED_FIBRE
 310                                      | ADVERTISED_1000baseT_Full);
 311                 break;
 312         case MDIO_PMAPMD_CTRL2_100_BT:
 313                 ecmd->speed = SPEED_100;
 314                 ecmd->port = PORT_TP;
 315                 ecmd->supported = SUPPORTED_TP | SUPPORTED_100baseT_Full;
 316                 ecmd->advertising = (ADVERTISED_FIBRE
 317                                      | ADVERTISED_100baseT_Full);
 318                 break;
 319         case MDIO_PMAPMD_CTRL2_10_BT:
 320                 ecmd->speed = SPEED_10;
 321                 ecmd->port = PORT_TP;
 322                 ecmd->supported = SUPPORTED_TP | SUPPORTED_10baseT_Full;
 323                 ecmd->advertising = ADVERTISED_FIBRE | ADVERTISED_10baseT_Full;
 324                 break;
 325         /* All the other defined modes are flavours of
 326          * 10G optical */
 327         default:
 328                 ecmd->speed = SPEED_10000;
 329                 ecmd->port = PORT_FIBRE;
 330                 ecmd->supported = SUPPORTED_FIBRE;
 331                 ecmd->advertising = ADVERTISED_FIBRE;
 332                 break;
 333         }
 334 }
 335
 336 /**
 337  * mdio_clause45_set_settings - Set (some of) the PHY settings over MDIO.
 338  * @efx:                Efx NIC
 339  * @ecmd:               New settings
 340  *
 341  * Currently this just enforces that we are _not_ changing the
 342  * 'port', 'speed', 'supported' or 'advertising' settings as these
 343  * cannot be changed on any currently supported PHY.
 344  */
 345 int mdio_clause45_set_settings(struct efx_nic *efx,
 346                                struct ethtool_cmd *ecmd)
 347 {
 348         struct ethtool_cmd tmpcmd;
 349         mdio_clause45_get_settings(efx, &tmpcmd);
 350         /* None of the current PHYs support more than one mode
 351          * of operation (and only 10GBT ever will), so keep things
 352          * simple for now */
 353         if ((ecmd->speed == tmpcmd.speed) && (ecmd->port == tmpcmd.port) &&
 354             (ecmd->supported == tmpcmd.supported) &&
 355             (ecmd->advertising == tmpcmd.advertising))
 356                 return 0;
 357         return -EOPNOTSUPP;
 358 }