drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_param.c

   1 /*
   2  * Copyright (C) 1999 - 2010 Intel Corporation.
   3  * Copyright (C) 2010 OKI SEMICONDUCTOR Co., LTD.
   4  *
   5  * This code was derived from the Intel e1000e Linux driver.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; version 2 of the License.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  19  */
  20
  21 #include "pch_gbe.h"
  22 #include <linux/module.h>       /* for __MODULE_STRING */
  23
  24 #define OPTION_UNSET   -1
  25 #define OPTION_DISABLED 0
  26 #define OPTION_ENABLED  1
  27
  28 /**
  29  * TxDescriptors - Transmit Descriptor Count
  30  * @Valid Range:   PCH_GBE_MIN_TXD - PCH_GBE_MAX_TXD
  31  * @Default Value: PCH_GBE_DEFAULT_TXD
  32  */
  33 static int TxDescriptors = OPTION_UNSET;
  34 module_param(TxDescriptors, int, 0);
  35 MODULE_PARM_DESC(TxDescriptors, "Number of transmit descriptors");
  36
  37 /**
  38  * RxDescriptors -Receive Descriptor Count
  39  * @Valid Range:   PCH_GBE_MIN_RXD - PCH_GBE_MAX_RXD
  40  * @Default Value: PCH_GBE_DEFAULT_RXD
  41  */
  42 static int RxDescriptors = OPTION_UNSET;
  43 module_param(RxDescriptors, int, 0);
  44 MODULE_PARM_DESC(RxDescriptors, "Number of receive descriptors");
  45
  46 /**
  47  * Speed - User Specified Speed Override
  48  * @Valid Range: 0, 10, 100, 1000
  49  *   - 0:    auto-negotiate at all supported speeds
  50  *   - 10:   only link at 10 Mbps
  51  *   - 100:  only link at 100 Mbps
  52  *   - 1000: only link at 1000 Mbps
  53  * @Default Value: 0
  54  */
  55 static int Speed = OPTION_UNSET;
  56 module_param(Speed, int, 0);
  57 MODULE_PARM_DESC(Speed, "Speed setting");
  58
  59 /**
  60  * Duplex - User Specified Duplex Override
  61  * @Valid Range: 0-2
  62  *   - 0:  auto-negotiate for duplex
  63  *   - 1:  only link at half duplex
  64  *   - 2:  only link at full duplex
  65  * @Default Value: 0
  66  */
  67 static int Duplex = OPTION_UNSET;
  68 module_param(Duplex, int, 0);
  69 MODULE_PARM_DESC(Duplex, "Duplex setting");
  70
  71 #define HALF_DUPLEX 1
  72 #define FULL_DUPLEX 2
  73
  74 /**
  75  * AutoNeg - Auto-negotiation Advertisement Override
  76  * @Valid Range: 0x01-0x0F, 0x20-0x2F
  77  *
  78  *       The AutoNeg value is a bit mask describing which speed and duplex
  79  *       combinations should be advertised during auto-negotiation.
  80  *       The supported speed and duplex modes are listed below
  81  *
  82  *       Bit           7     6     5      4      3     2     1      0
  83  *       Speed (Mbps)  N/A   N/A   1000   N/A    100   100   10     10
  84  *       Duplex                    Full          Full  Half  Full   Half
  85  *
  86  * @Default Value: 0x2F (copper)
  87  */
  88 static int AutoNeg = OPTION_UNSET;
  89 module_param(AutoNeg, int, 0);
  90 MODULE_PARM_DESC(AutoNeg, "Advertised auto-negotiation setting");
  91
  92 #define PHY_ADVERTISE_10_HALF      0x0001
  93 #define PHY_ADVERTISE_10_FULL      0x0002
  94 #define PHY_ADVERTISE_100_HALF     0x0004
  95 #define PHY_ADVERTISE_100_FULL     0x0008
  96 #define PHY_ADVERTISE_1000_HALF    0x0010 /* Not used, just FYI */
  97 #define PHY_ADVERTISE_1000_FULL    0x0020
  98 #define PCH_AUTONEG_ADVERTISE_DEFAULT   0x2F
  99
 100 /**
 101  * FlowControl - User Specified Flow Control Override
 102  * @Valid Range: 0-3
 103  *    - 0:  No Flow Control
 104  *    - 1:  Rx only, respond to PAUSE frames but do not generate them
 105  *    - 2:  Tx only, generate PAUSE frames but ignore them on receive
 106  *    - 3:  Full Flow Control Support
 107  * @Default Value: Read flow control settings from the EEPROM
 108  */
 109 static int FlowControl = OPTION_UNSET;
 110 module_param(FlowControl, int, 0);
 111 MODULE_PARM_DESC(FlowControl, "Flow Control setting");
 112
 113 /*
 114  * XsumRX - Receive Checksum Offload Enable/Disable
 115  * @Valid Range: 0, 1
 116  *    - 0:  disables all checksum offload
 117  *    - 1:  enables receive IP/TCP/UDP checksum offload
 118  * @Default Value: PCH_GBE_DEFAULT_RX_CSUM
 119  */
 120 static int XsumRX = OPTION_UNSET;
 121 module_param(XsumRX, int, 0);
 122 MODULE_PARM_DESC(XsumRX, "Disable or enable Receive Checksum offload");
 123
 124 #define PCH_GBE_DEFAULT_RX_CSUM             true        /* trueorfalse */
 125
 126 /*
 127  * XsumTX - Transmit Checksum Offload Enable/Disable
 128  * @Valid Range: 0, 1
 129  *    - 0:  disables all checksum offload
 130  *    - 1:  enables transmit IP/TCP/UDP checksum offload
 131  * @Default Value: PCH_GBE_DEFAULT_TX_CSUM
 132  */
 133 static int XsumTX = OPTION_UNSET;
 134 module_param(XsumTX, int, 0);
 135 MODULE_PARM_DESC(XsumTX, "Disable or enable Transmit Checksum offload");
 136
 137 #define PCH_GBE_DEFAULT_TX_CSUM             true        /* trueorfalse */
 138
 139 /**
 140  * pch_gbe_option - Force the MAC's flow control settings
 141  * @hw:             Pointer to the HW structure
 142  * Returns:
 143  *      0:                      Successful.
 144  *      Negative value:         Failed.
 145  */
 146 struct pch_gbe_option {
 147         enum { enable_option, range_option, list_option } type;
 148         char *name;
 149         char *err;
 150         int  def;
 151         union {
 152                 struct { /* range_option info */
 153                         int min;
 154                         int max;
 155                 } r;
 156                 struct { /* list_option info */
 157                         int nr;
 158                         const struct pch_gbe_opt_list { int i; char *str; } *p;
 159                 } l;
 160         } arg;
 161 };
 162
 163 static const struct pch_gbe_opt_list speed_list[] = {
 164         { 0, "" },
 165         { SPEED_10, "" },
 166         { SPEED_100, "" },
 167         { SPEED_1000, "" }
 168 };
 169
 170 static const struct pch_gbe_opt_list dplx_list[] = {
 171         { 0, "" },
 172         { HALF_DUPLEX, "" },
 173         { FULL_DUPLEX, "" }
 174 };
 175
 176 static const struct pch_gbe_opt_list an_list[] =
 177         #define AA "AutoNeg advertising "
 178         {{ 0x01, AA "10/HD" },
 179          { 0x02, AA "10/FD" },
 180          { 0x03, AA "10/FD, 10/HD" },
 181          { 0x04, AA "100/HD" },
 182          { 0x05, AA "100/HD, 10/HD" },
 183          { 0x06, AA "100/HD, 10/FD" },
 184          { 0x07, AA "100/HD, 10/FD, 10/HD" },
 185          { 0x08, AA "100/FD" },
 186          { 0x09, AA "100/FD, 10/HD" },
 187          { 0x0a, AA "100/FD, 10/FD" },
 188          { 0x0b, AA "100/FD, 10/FD, 10/HD" },
 189          { 0x0c, AA "100/FD, 100/HD" },
 190          { 0x0d, AA "100/FD, 100/HD, 10/HD" },
 191          { 0x0e, AA "100/FD, 100/HD, 10/FD" },
 192          { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" },
 193          { 0x20, AA "1000/FD" },
 194          { 0x21, AA "1000/FD, 10/HD" },
 195          { 0x22, AA "1000/FD, 10/FD" },
 196          { 0x23, AA "1000/FD, 10/FD, 10/HD" },
 197          { 0x24, AA "1000/FD, 100/HD" },
 198          { 0x25, AA "1000/FD, 100/HD, 10/HD" },
 199          { 0x26, AA "1000/FD, 100/HD, 10/FD" },
 200          { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" },
 201          { 0x28, AA "1000/FD, 100/FD" },
 202          { 0x29, AA "1000/FD, 100/FD, 10/HD" },
 203          { 0x2a, AA "1000/FD, 100/FD, 10/FD" },
 204          { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" },
 205          { 0x2c, AA "1000/FD, 100/FD, 100/HD" },
 206          { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" },
 207          { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" },
 208          { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }
 209 };
 210
 211 static const struct pch_gbe_opt_list fc_list[] = {
 212         { PCH_GBE_FC_NONE, "Flow Control Disabled" },
 213         { PCH_GBE_FC_RX_PAUSE, "Flow Control Receive Only" },
 214         { PCH_GBE_FC_TX_PAUSE, "Flow Control Transmit Only" },
 215         { PCH_GBE_FC_FULL, "Flow Control Enabled" }
 216 };
 217
 218 /**
 219  * pch_gbe_validate_option - Validate option
 220  * @value:    value
 221  * @opt:      option
 222  * @adapter:  Board private structure
 223  * Returns:
 224  *      0:                      Successful.
 225  *      Negative value:         Failed.
 226  */
 227 static int pch_gbe_validate_option(int *value,
 228                                     const struct pch_gbe_option *opt,
 229                                     struct pch_gbe_adapter *adapter)
 230 {
 231         if (*value == OPTION_UNSET) {
 232                 *value = opt->def;
 233                 return 0;
 234         }
 235
 236         switch (opt->type) {
 237         case enable_option:
 238                 switch (*value) {
 239                 case OPTION_ENABLED:
 240                         netdev_dbg(adapter->netdev, "%s Enabled\n", opt->name);
 241                         return 0;
 242                 case OPTION_DISABLED:
 243                         netdev_dbg(adapter->netdev, "%s Disabled\n", opt->name);
 244                         return 0;
 245                 }
 246                 break;
 247         case range_option:
 248                 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
 249                         netdev_dbg(adapter->netdev, "%s set to %i\n",
 250                                    opt->name, *value);
 251                         return 0;
 252                 }
 253                 break;
 254         case list_option: {
 255                 int i;
 256                 const struct pch_gbe_opt_list *ent;
 257
 258                 for (i = 0; i < opt->arg.l.nr; i++) {
 259                         ent = &opt->arg.l.p[i];
 260                         if (*value == ent->i) {
 261                                 if (ent->str[0] != '\0')
 262                                         netdev_dbg(adapter->netdev, "%s\n",
 263                                                    ent->str);
 264                                 return 0;
 265                         }
 266                 }
 267         }
 268                 break;
 269         default:
 270                 BUG();
 271         }
 272
 273         netdev_dbg(adapter->netdev, "Invalid %s value specified (%i) %s\n",
 274                    opt->name, *value, opt->err);
 275         *value = opt->def;
 276         return -1;
 277 }
 278
 279 /**
 280  * pch_gbe_check_copper_options - Range Checking for Link Options, Copper Version
 281  * @adapter:  Board private structure
 282  */
 283 static void pch_gbe_check_copper_options(struct pch_gbe_adapter *adapter)
 284 {
 285         struct pch_gbe_hw *hw = &adapter->hw;
 286         int speed, dplx;
 287
 288         { /* Speed */
 289                 static const struct pch_gbe_option opt = {
 290                         .type = list_option,
 291                         .name = "Speed",
 292                         .err  = "parameter ignored",
 293                         .def  = 0,
 294                         .arg  = { .l = { .nr = (int)ARRAY_SIZE(speed_list),
 295                                          .p = speed_list } }
 296                 };
 297                 speed = Speed;
 298                 pch_gbe_validate_option(&speed, &opt, adapter);
 299         }
 300         { /* Duplex */
 301                 static const struct pch_gbe_option opt = {
 302                         .type = list_option,
 303                         .name = "Duplex",
 304                         .err  = "parameter ignored",
 305                         .def  = 0,
 306                         .arg  = { .l = { .nr = (int)ARRAY_SIZE(dplx_list),
 307                                          .p = dplx_list } }
 308                 };
 309                 dplx = Duplex;
 310                 pch_gbe_validate_option(&dplx, &opt, adapter);
 311         }
 312
 313         { /* Autoneg */
 314                 static const struct pch_gbe_option opt = {
 315                         .type = list_option,
 316                         .name = "AutoNeg",
 317                         .err  = "parameter ignored",
 318                         .def  = PCH_AUTONEG_ADVERTISE_DEFAULT,
 319                         .arg  = { .l = { .nr = (int)ARRAY_SIZE(an_list),
 320                                          .p = an_list} }
 321                 };
 322                 if (speed || dplx) {
 323                         netdev_dbg(adapter->netdev,
 324                                    "AutoNeg specified along with Speed or Duplex, AutoNeg parameter ignored\n");
 325                         hw->phy.autoneg_advertised = opt.def;
 326                 } else {
 327                         int tmp = AutoNeg;
 328
 329                         pch_gbe_validate_option(&tmp, &opt, adapter);
 330                         hw->phy.autoneg_advertised = tmp;
 331                 }
 332         }
 333
 334         switch (speed + dplx) {
 335         case 0:
 336                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
 337                 if ((speed || dplx))
 338                         netdev_dbg(adapter->netdev,
 339                                    "Speed and duplex autonegotiation enabled\n");
 340                 hw->mac.link_speed = SPEED_10;
 341                 hw->mac.link_duplex = DUPLEX_HALF;
 342                 break;
 343         case HALF_DUPLEX:
 344                 netdev_dbg(adapter->netdev,
 345                            "Half Duplex specified without Speed\n");
 346                 netdev_dbg(adapter->netdev,
 347                            "Using Autonegotiation at Half Duplex only\n");
 348                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
 349                 hw->phy.autoneg_advertised = PHY_ADVERTISE_10_HALF |
 350                                                 PHY_ADVERTISE_100_HALF;
 351                 hw->mac.link_speed = SPEED_10;
 352                 hw->mac.link_duplex = DUPLEX_HALF;
 353                 break;
 354         case FULL_DUPLEX:
 355                 netdev_dbg(adapter->netdev,
 356                            "Full Duplex specified without Speed\n");
 357                 netdev_dbg(adapter->netdev,
 358                            "Using Autonegotiation at Full Duplex only\n");
 359                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
 360                 hw->phy.autoneg_advertised = PHY_ADVERTISE_10_FULL |
 361                                                 PHY_ADVERTISE_100_FULL |
 362                                                 PHY_ADVERTISE_1000_FULL;
 363                 hw->mac.link_speed = SPEED_10;
 364                 hw->mac.link_duplex = DUPLEX_FULL;
 365                 break;
 366         case SPEED_10:
 367                 netdev_dbg(adapter->netdev,
 368                            "10 Mbps Speed specified without Duplex\n");
 369                 netdev_dbg(adapter->netdev,
 370                            "Using Autonegotiation at 10 Mbps only\n");
 371                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
 372                 hw->phy.autoneg_advertised = PHY_ADVERTISE_10_HALF |
 373                                                 PHY_ADVERTISE_10_FULL;
 374                 hw->mac.link_speed = SPEED_10;
 375                 hw->mac.link_duplex = DUPLEX_HALF;
 376                 break;
 377         case SPEED_10 + HALF_DUPLEX:
 378                 netdev_dbg(adapter->netdev, "Forcing to 10 Mbps Half Duplex\n");
 379                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
 380                 hw->phy.autoneg_advertised = 0;
 381                 hw->mac.link_speed = SPEED_10;
 382                 hw->mac.link_duplex = DUPLEX_HALF;
 383                 break;
 384         case SPEED_10 + FULL_DUPLEX:
 385                 netdev_dbg(adapter->netdev, "Forcing to 10 Mbps Full Duplex\n");
 386                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
 387                 hw->phy.autoneg_advertised = 0;
 388                 hw->mac.link_speed = SPEED_10;
 389                 hw->mac.link_duplex = DUPLEX_FULL;
 390                 break;
 391         case SPEED_100:
 392                 netdev_dbg(adapter->netdev,
 393                            "100 Mbps Speed specified without Duplex\n");
 394                 netdev_dbg(adapter->netdev,
 395                            "Using Autonegotiation at 100 Mbps only\n");
 396                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
 397                 hw->phy.autoneg_advertised = PHY_ADVERTISE_100_HALF |
 398                                                 PHY_ADVERTISE_100_FULL;
 399                 hw->mac.link_speed = SPEED_100;
 400                 hw->mac.link_duplex = DUPLEX_HALF;
 401                 break;
 402         case SPEED_100 + HALF_DUPLEX:
 403                 netdev_dbg(adapter->netdev,
 404                            "Forcing to 100 Mbps Half Duplex\n");
 405                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
 406                 hw->phy.autoneg_advertised = 0;
 407                 hw->mac.link_speed = SPEED_100;
 408                 hw->mac.link_duplex = DUPLEX_HALF;
 409                 break;
 410         case SPEED_100 + FULL_DUPLEX:
 411                 netdev_dbg(adapter->netdev,
 412                            "Forcing to 100 Mbps Full Duplex\n");
 413                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
 414                 hw->phy.autoneg_advertised = 0;
 415                 hw->mac.link_speed = SPEED_100;
 416                 hw->mac.link_duplex = DUPLEX_FULL;
 417                 break;
 418         case SPEED_1000:
 419                 netdev_dbg(adapter->netdev,
 420                            "1000 Mbps Speed specified without Duplex\n");
 421                 goto full_duplex_only;
 422         case SPEED_1000 + HALF_DUPLEX:
 423                 netdev_dbg(adapter->netdev,
 424                            "Half Duplex is not supported at 1000 Mbps\n");
 425                 /* fall through */
 426         case SPEED_1000 + FULL_DUPLEX:
 427 full_duplex_only:
 428                 netdev_dbg(adapter->netdev,
 429                            "Using Autonegotiation at 1000 Mbps Full Duplex only\n");
 430                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
 431                 hw->phy.autoneg_advertised = PHY_ADVERTISE_1000_FULL;
 432                 hw->mac.link_speed = SPEED_1000;
 433                 hw->mac.link_duplex = DUPLEX_FULL;
 434                 break;
 435         default:
 436                 BUG();
 437         }
 438 }
 439
 440 /**
 441  * pch_gbe_check_options - Range Checking for Command Line Parameters
 442  * @adapter:  Board private structure
 443  */
 444 void pch_gbe_check_options(struct pch_gbe_adapter *adapter)
 445 {
 446         struct pch_gbe_hw *hw = &adapter->hw;
 447         struct net_device *dev = adapter->netdev;
 448         int val;
 449
 450         { /* Transmit Descriptor Count */
 451                 static const struct pch_gbe_option opt = {
 452                         .type = range_option,
 453                         .name = "Transmit Descriptors",
 454                         .err  = "using default of "
 455                                 __MODULE_STRING(PCH_GBE_DEFAULT_TXD),
 456                         .def  = PCH_GBE_DEFAULT_TXD,
 457                         .arg  = { .r = { .min = PCH_GBE_MIN_TXD,
 458                                          .max = PCH_GBE_MAX_TXD } }
 459                 };
 460                 struct pch_gbe_tx_ring *tx_ring = adapter->tx_ring;
 461                 tx_ring->count = TxDescriptors;
 462                 pch_gbe_validate_option(&tx_ring->count, &opt, adapter);
 463                 tx_ring->count = roundup(tx_ring->count,
 464                                         PCH_GBE_TX_DESC_MULTIPLE);
 465         }
 466         { /* Receive Descriptor Count */
 467                 static const struct pch_gbe_option opt = {
 468                         .type = range_option,
 469                         .name = "Receive Descriptors",
 470                         .err  = "using default of "
 471                                 __MODULE_STRING(PCH_GBE_DEFAULT_RXD),
 472                         .def  = PCH_GBE_DEFAULT_RXD,
 473                         .arg  = { .r = { .min = PCH_GBE_MIN_RXD,
 474                                          .max = PCH_GBE_MAX_RXD } }
 475                 };
 476                 struct pch_gbe_rx_ring *rx_ring = adapter->rx_ring;
 477                 rx_ring->count = RxDescriptors;
 478                 pch_gbe_validate_option(&rx_ring->count, &opt, adapter);
 479                 rx_ring->count = roundup(rx_ring->count,
 480                                 PCH_GBE_RX_DESC_MULTIPLE);
 481         }
 482         { /* Checksum Offload Enable/Disable */
 483                 static const struct pch_gbe_option opt = {
 484                         .type = enable_option,
 485                         .name = "Checksum Offload",
 486                         .err  = "defaulting to Enabled",
 487                         .def  = PCH_GBE_DEFAULT_RX_CSUM
 488                 };
 489                 val = XsumRX;
 490                 pch_gbe_validate_option(&val, &opt, adapter);
 491                 if (!val)
 492                         dev->features &= ~NETIF_F_RXCSUM;
 493         }
 494         { /* Checksum Offload Enable/Disable */
 495                 static const struct pch_gbe_option opt = {
 496                         .type = enable_option,
 497                         .name = "Checksum Offload",
 498                         .err  = "defaulting to Enabled",
 499                         .def  = PCH_GBE_DEFAULT_TX_CSUM
 500                 };
 501                 val = XsumTX;
 502                 pch_gbe_validate_option(&val, &opt, adapter);
 503                 if (!val)
 504                         dev->features &= ~NETIF_F_ALL_CSUM;
 505         }
 506         { /* Flow Control */
 507                 static const struct pch_gbe_option opt = {
 508                         .type = list_option,
 509                         .name = "Flow Control",
 510                         .err  = "reading default settings from EEPROM",
 511                         .def  = PCH_GBE_FC_DEFAULT,
 512                         .arg  = { .l = { .nr = (int)ARRAY_SIZE(fc_list),
 513                                          .p = fc_list } }
 514                 };
 515                 int tmp = FlowControl;
 516
 517                 pch_gbe_validate_option(&tmp, &opt, adapter);
 518                 hw->mac.fc = tmp;
 519         }
 520
 521         pch_gbe_check_copper_options(adapter);
 522 }