?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.11-rc3
[cris-mirror.git] / drivers / net / ethernet / oki-semi / pch_gbe / pch_gbe_param.c
blobcf7c9b3a255b40cf6e4c949e248303994be07287
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 }
CRIS linux kernel tree