git.oblomov.eu Git - linux-2.6/blob - 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         u32 devices;
 125         int mmd = 0, 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_DEVS_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                    mdio_clause45_read(efx, efx->mii.phy_id,
 135                                       probe_mmd, MDIO_MMDREG_DEVS1) << 16);
 136
 137         /* Check all the expected MMDs are present */
 138         if (devices < 0) {
 139                 EFX_ERR(efx, "failed to read devices present\n");
 140                 return -EIO;
 141         }
 142         if ((devices & mmd_mask) != mmd_mask) {
 143                 EFX_ERR(efx, "required MMDs not present: got %x, "
 144                         "wanted %x\n", devices, mmd_mask);
 145                 return -ENODEV;
 146         }
 147         EFX_TRACE(efx, "Devices present: %x\n", devices);
 148
 149         /* Check all required MMDs are responding and happy. */
 150         while (mmd_mask) {
 151                 if (mmd_mask & 1) {
 152                         int fault_fatal = fatal_mask & 1;
 153                         if (mdio_clause45_check_mmd(efx, mmd, fault_fatal))
 154                                 return -EIO;
 155                 }
 156                 mmd_mask = mmd_mask >> 1;
 157                 fatal_mask = fatal_mask >> 1;
 158                 mmd++;
 159         }
 160
 161         return 0;
 162 }
 163
 164 bool mdio_clause45_links_ok(struct efx_nic *efx, unsigned int mmd_mask)
 165 {
 166         int phy_id = efx->mii.phy_id;
 167         int status;
 168         bool ok = true;
 169         int mmd = 0;
 170
 171         /* If the port is in loopback, then we should only consider a subset
 172          * of mmd's */
 173         if (LOOPBACK_INTERNAL(efx))
 174                 return true;
 175         else if (efx->loopback_mode == LOOPBACK_NETWORK)
 176                 return false;
 177         else if (efx_phy_mode_disabled(efx->phy_mode))
 178                 return false;
 179         else if (efx->loopback_mode == LOOPBACK_PHYXS)
 180                 mmd_mask &= ~(MDIO_MMDREG_DEVS_PHYXS |
 181                               MDIO_MMDREG_DEVS_PCS |
 182                               MDIO_MMDREG_DEVS_PMAPMD);
 183         else if (efx->loopback_mode == LOOPBACK_PCS)
 184                 mmd_mask &= ~(MDIO_MMDREG_DEVS_PCS |
 185                               MDIO_MMDREG_DEVS_PMAPMD);
 186         else if (efx->loopback_mode == LOOPBACK_PMAPMD)
 187                 mmd_mask &= ~MDIO_MMDREG_DEVS_PMAPMD;
 188
 189         while (mmd_mask) {
 190                 if (mmd_mask & 1) {
 191                         /* Double reads because link state is latched, and a
 192                          * read moves the current state into the register */
 193                         status = mdio_clause45_read(efx, phy_id,
 194                                                     mmd, MDIO_MMDREG_STAT1);
 195                         status = mdio_clause45_read(efx, phy_id,
 196                                                     mmd, MDIO_MMDREG_STAT1);
 197
 198                         ok = ok && (status & (1 << MDIO_MMDREG_STAT1_LINK_LBN));
 199                 }
 200                 mmd_mask = (mmd_mask >> 1);
 201                 mmd++;
 202         }
 203         return ok;
 204 }
 205
 206 void mdio_clause45_transmit_disable(struct efx_nic *efx)
 207 {
 208         int phy_id = efx->mii.phy_id;
 209         int ctrl1, ctrl2;
 210
 211         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
 212                                            MDIO_MMDREG_TXDIS);
 213         if (efx->phy_mode & PHY_MODE_TX_DISABLED)
 214                 ctrl2 |= (1 << MDIO_MMDREG_TXDIS_GLOBAL_LBN);
 215         else
 216                 ctrl1 &= ~(1 << MDIO_MMDREG_TXDIS_GLOBAL_LBN);
 217         if (ctrl1 != ctrl2)
 218                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD,
 219                                     MDIO_MMDREG_TXDIS, ctrl2);
 220 }
 221
 222 void mdio_clause45_phy_reconfigure(struct efx_nic *efx)
 223 {
 224         int phy_id = efx->mii.phy_id;
 225         int ctrl1, ctrl2;
 226
 227         /* Handle (with debouncing) PMA/PMD loopback */
 228         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PMAPMD,
 229                                            MDIO_MMDREG_CTRL1);
 230
 231         if (efx->loopback_mode == LOOPBACK_PMAPMD)
 232                 ctrl2 |= (1 << MDIO_PMAPMD_CTRL1_LBACK_LBN);
 233         else
 234                 ctrl2 &= ~(1 << MDIO_PMAPMD_CTRL1_LBACK_LBN);
 235
 236         if (ctrl1 != ctrl2)
 237                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PMAPMD,
 238                                     MDIO_MMDREG_CTRL1, ctrl2);
 239
 240         /* Handle (with debouncing) PCS loopback */
 241         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PCS,
 242                                            MDIO_MMDREG_CTRL1);
 243         if (efx->loopback_mode == LOOPBACK_PCS)
 244                 ctrl2 |= (1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 245         else
 246                 ctrl2 &= ~(1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 247
 248         if (ctrl1 != ctrl2)
 249                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PCS,
 250                                     MDIO_MMDREG_CTRL1, ctrl2);
 251
 252         /* Handle (with debouncing) PHYXS network loopback */
 253         ctrl1 = ctrl2 = mdio_clause45_read(efx, phy_id, MDIO_MMD_PHYXS,
 254                                            MDIO_MMDREG_CTRL1);
 255         if (efx->loopback_mode == LOOPBACK_NETWORK)
 256                 ctrl2 |= (1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 257         else
 258                 ctrl2 &= ~(1 << MDIO_MMDREG_CTRL1_LBACK_LBN);
 259
 260         if (ctrl1 != ctrl2)
 261                 mdio_clause45_write(efx, phy_id, MDIO_MMD_PHYXS,
 262                                     MDIO_MMDREG_CTRL1, ctrl2);
 263 }
 264
 265 static void mdio_clause45_set_mmd_lpower(struct efx_nic *efx,
 266                                          int lpower, int mmd)
 267 {
 268         int phy = efx->mii.phy_id;
 269         int stat = mdio_clause45_read(efx, phy, mmd, MDIO_MMDREG_STAT1);
 270         int ctrl1, ctrl2;
 271
 272         EFX_TRACE(efx, "Setting low power mode for MMD %d to %d\n",
 273                   mmd, lpower);
 274
 275         if (stat & (1 << MDIO_MMDREG_STAT1_LPABLE_LBN)) {
 276                 ctrl1 = ctrl2 = mdio_clause45_read(efx, phy,
 277                                                    mmd, MDIO_MMDREG_CTRL1);
 278                 if (lpower)
 279                         ctrl2 |= (1 << MDIO_MMDREG_CTRL1_LPOWER_LBN);
 280                 else
 281                         ctrl2 &= ~(1 << MDIO_MMDREG_CTRL1_LPOWER_LBN);
 282                 if (ctrl1 != ctrl2)
 283                         mdio_clause45_write(efx, phy, mmd,
 284                                             MDIO_MMDREG_CTRL1, ctrl2);
 285         }
 286 }
 287
 288 void mdio_clause45_set_mmds_lpower(struct efx_nic *efx,
 289                                    int low_power, unsigned int mmd_mask)
 290 {
 291         int mmd = 0;
 292         while (mmd_mask) {
 293                 if (mmd_mask & 1)
 294                         mdio_clause45_set_mmd_lpower(efx, low_power, mmd);
 295                 mmd_mask = (mmd_mask >> 1);
 296                 mmd++;
 297         }
 298 }
 299
 300 /**
 301  * mdio_clause45_get_settings - Read (some of) the PHY settings over MDIO.
 302  * @efx:                Efx NIC
 303  * @ecmd:               Buffer for settings
 304  *
 305  * On return the 'port', 'speed', 'supported' and 'advertising' fields of
 306  * ecmd have been filled out based on the PMA type.
 307  */
 308 void mdio_clause45_get_settings(struct efx_nic *efx,
 309                                 struct ethtool_cmd *ecmd)
 310 {
 311         int pma_type;
 312
 313         /* If no PMA is present we are presumably talking something XAUI-ish
 314          * like CX4. Which we report as FIBRE (see below) */
 315         if ((efx->phy_op->mmds & DEV_PRESENT_BIT(MDIO_MMD_PMAPMD)) == 0) {
 316                 ecmd->speed = SPEED_10000;
 317                 ecmd->port = PORT_FIBRE;
 318                 ecmd->supported = SUPPORTED_FIBRE;
 319                 ecmd->advertising = ADVERTISED_FIBRE;
 320                 return;
 321         }
 322
 323         pma_type = mdio_clause45_read(efx, efx->mii.phy_id,
 324                                       MDIO_MMD_PMAPMD, MDIO_MMDREG_CTRL2);
 325         pma_type &= MDIO_PMAPMD_CTRL2_TYPE_MASK;
 326
 327         switch (pma_type) {
 328                 /* We represent CX4 as fibre in the absence of anything
 329                    better. */
 330         case MDIO_PMAPMD_CTRL2_10G_CX4:
 331                 ecmd->speed = SPEED_10000;
 332                 ecmd->port = PORT_FIBRE;
 333                 ecmd->supported = SUPPORTED_FIBRE;
 334                 ecmd->advertising = ADVERTISED_FIBRE;
 335                 break;
 336                 /* 10G Base-T */
 337         case MDIO_PMAPMD_CTRL2_10G_BT:
 338                 ecmd->speed = SPEED_10000;
 339                 ecmd->port = PORT_TP;
 340                 ecmd->supported = SUPPORTED_TP | SUPPORTED_10000baseT_Full;
 341                 ecmd->advertising = (ADVERTISED_FIBRE
 342                                      | ADVERTISED_10000baseT_Full);
 343                 break;
 344         case MDIO_PMAPMD_CTRL2_1G_BT:
 345                 ecmd->speed = SPEED_1000;
 346                 ecmd->port = PORT_TP;
 347                 ecmd->supported = SUPPORTED_TP | SUPPORTED_1000baseT_Full;
 348                 ecmd->advertising = (ADVERTISED_FIBRE
 349                                      | ADVERTISED_1000baseT_Full);
 350                 break;
 351         case MDIO_PMAPMD_CTRL2_100_BT:
 352                 ecmd->speed = SPEED_100;
 353                 ecmd->port = PORT_TP;
 354                 ecmd->supported = SUPPORTED_TP | SUPPORTED_100baseT_Full;
 355                 ecmd->advertising = (ADVERTISED_FIBRE
 356                                      | ADVERTISED_100baseT_Full);
 357                 break;
 358         case MDIO_PMAPMD_CTRL2_10_BT:
 359                 ecmd->speed = SPEED_10;
 360                 ecmd->port = PORT_TP;
 361                 ecmd->supported = SUPPORTED_TP | SUPPORTED_10baseT_Full;
 362                 ecmd->advertising = ADVERTISED_FIBRE | ADVERTISED_10baseT_Full;
 363                 break;
 364         /* All the other defined modes are flavours of
 365          * 10G optical */
 366         default:
 367                 ecmd->speed = SPEED_10000;
 368                 ecmd->port = PORT_FIBRE;
 369                 ecmd->supported = SUPPORTED_FIBRE;
 370                 ecmd->advertising = ADVERTISED_FIBRE;
 371                 break;
 372         }
 373 }
 374
 375 /**
 376  * mdio_clause45_set_settings - Set (some of) the PHY settings over MDIO.
 377  * @efx:                Efx NIC
 378  * @ecmd:               New settings
 379  *
 380  * Currently this just enforces that we are _not_ changing the
 381  * 'port', 'speed', 'supported' or 'advertising' settings as these
 382  * cannot be changed on any currently supported PHY.
 383  */
 384 int mdio_clause45_set_settings(struct efx_nic *efx,
 385                                struct ethtool_cmd *ecmd)
 386 {
 387         struct ethtool_cmd tmpcmd;
 388         mdio_clause45_get_settings(efx, &tmpcmd);
 389         /* None of the current PHYs support more than one mode
 390          * of operation (and only 10GBT ever will), so keep things
 391          * simple for now */
 392         if ((ecmd->speed == tmpcmd.speed) && (ecmd->port == tmpcmd.port) &&
 393             (ecmd->supported == tmpcmd.supported) &&
 394             (ecmd->advertising == tmpcmd.advertising))
 395                 return 0;
 396         return -EOPNOTSUPP;
 397 }