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