Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ethtool.c
Go to the documentation of this file.
1 /*******************************************************************************
2 
3  Intel PRO/1000 Linux driver
4  Copyright(c) 1999 - 2012 Intel Corporation.
5 
6  This program is free software; you can redistribute it and/or modify it
7  under the terms and conditions of the GNU General Public License,
8  version 2, as published by the Free Software Foundation.
9 
10  This program is distributed in the hope it will be useful, but WITHOUT
11  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13  more details.
14 
15  You should have received a copy of the GNU General Public License along with
16  this program; if not, write to the Free Software Foundation, Inc.,
17  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 
19  The full GNU General Public License is included in this distribution in
20  the file called "COPYING".
21 
22  Contact Information:
23  Linux NICS <[email protected]>
24  e1000-devel Mailing List <[email protected]>
25  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26 
27 *******************************************************************************/
28 
29 /* ethtool support for e1000 */
30 
31 #include <linux/netdevice.h>
32 #include <linux/interrupt.h>
33 #include <linux/ethtool.h>
34 #include <linux/pci.h>
35 #include <linux/slab.h>
36 #include <linux/delay.h>
37 #include <linux/vmalloc.h>
38 
39 #include "e1000.h"
40 
41 enum {NETDEV_STATS, E1000_STATS};
42 
43 struct e1000_stats {
44  char stat_string[ETH_GSTRING_LEN];
45  int type;
46  int sizeof_stat;
47  int stat_offset;
48 };
49 
50 #define E1000_STAT(str, m) { \
51  .stat_string = str, \
52  .type = E1000_STATS, \
53  .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \
54  .stat_offset = offsetof(struct e1000_adapter, m) }
55 #define E1000_NETDEV_STAT(str, m) { \
56  .stat_string = str, \
57  .type = NETDEV_STATS, \
58  .sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \
59  .stat_offset = offsetof(struct rtnl_link_stats64, m) }
60 
61 static const struct e1000_stats e1000_gstrings_stats[] = {
62  E1000_STAT("rx_packets", stats.gprc),
63  E1000_STAT("tx_packets", stats.gptc),
64  E1000_STAT("rx_bytes", stats.gorc),
65  E1000_STAT("tx_bytes", stats.gotc),
66  E1000_STAT("rx_broadcast", stats.bprc),
67  E1000_STAT("tx_broadcast", stats.bptc),
68  E1000_STAT("rx_multicast", stats.mprc),
69  E1000_STAT("tx_multicast", stats.mptc),
70  E1000_NETDEV_STAT("rx_errors", rx_errors),
71  E1000_NETDEV_STAT("tx_errors", tx_errors),
72  E1000_NETDEV_STAT("tx_dropped", tx_dropped),
73  E1000_STAT("multicast", stats.mprc),
74  E1000_STAT("collisions", stats.colc),
75  E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),
76  E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),
77  E1000_STAT("rx_crc_errors", stats.crcerrs),
78  E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),
79  E1000_STAT("rx_no_buffer_count", stats.rnbc),
80  E1000_STAT("rx_missed_errors", stats.mpc),
81  E1000_STAT("tx_aborted_errors", stats.ecol),
82  E1000_STAT("tx_carrier_errors", stats.tncrs),
83  E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),
84  E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),
85  E1000_STAT("tx_window_errors", stats.latecol),
86  E1000_STAT("tx_abort_late_coll", stats.latecol),
87  E1000_STAT("tx_deferred_ok", stats.dc),
88  E1000_STAT("tx_single_coll_ok", stats.scc),
89  E1000_STAT("tx_multi_coll_ok", stats.mcc),
90  E1000_STAT("tx_timeout_count", tx_timeout_count),
91  E1000_STAT("tx_restart_queue", restart_queue),
92  E1000_STAT("rx_long_length_errors", stats.roc),
93  E1000_STAT("rx_short_length_errors", stats.ruc),
94  E1000_STAT("rx_align_errors", stats.algnerrc),
95  E1000_STAT("tx_tcp_seg_good", stats.tsctc),
96  E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),
97  E1000_STAT("rx_flow_control_xon", stats.xonrxc),
98  E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),
99  E1000_STAT("tx_flow_control_xon", stats.xontxc),
100  E1000_STAT("tx_flow_control_xoff", stats.xofftxc),
101  E1000_STAT("rx_long_byte_count", stats.gorc),
102  E1000_STAT("rx_csum_offload_good", hw_csum_good),
103  E1000_STAT("rx_csum_offload_errors", hw_csum_err),
104  E1000_STAT("rx_header_split", rx_hdr_split),
105  E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),
106  E1000_STAT("tx_smbus", stats.mgptc),
107  E1000_STAT("rx_smbus", stats.mgprc),
108  E1000_STAT("dropped_smbus", stats.mgpdc),
109  E1000_STAT("rx_dma_failed", rx_dma_failed),
110  E1000_STAT("tx_dma_failed", tx_dma_failed),
111 };
112 
113 #define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)
114 #define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)
115 static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
116  "Register test (offline)", "Eeprom test (offline)",
117  "Interrupt test (offline)", "Loopback test (offline)",
118  "Link test (on/offline)"
119 };
120 #define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)
121 
122 static int e1000_get_settings(struct net_device *netdev,
123  struct ethtool_cmd *ecmd)
124 {
125  struct e1000_adapter *adapter = netdev_priv(netdev);
126  struct e1000_hw *hw = &adapter->hw;
127  u32 speed;
128 
129  if (hw->phy.media_type == e1000_media_type_copper) {
130 
131  ecmd->supported = (SUPPORTED_10baseT_Half |
132  SUPPORTED_10baseT_Full |
133  SUPPORTED_100baseT_Half |
134  SUPPORTED_100baseT_Full |
135  SUPPORTED_1000baseT_Full |
136  SUPPORTED_Autoneg |
137  SUPPORTED_TP);
138  if (hw->phy.type == e1000_phy_ife)
139  ecmd->supported &= ~SUPPORTED_1000baseT_Full;
140  ecmd->advertising = ADVERTISED_TP;
141 
142  if (hw->mac.autoneg == 1) {
143  ecmd->advertising |= ADVERTISED_Autoneg;
144  /* the e1000 autoneg seems to match ethtool nicely */
145  ecmd->advertising |= hw->phy.autoneg_advertised;
146  }
147 
148  ecmd->port = PORT_TP;
149  ecmd->phy_address = hw->phy.addr;
150  ecmd->transceiver = XCVR_INTERNAL;
151 
152  } else {
153  ecmd->supported = (SUPPORTED_1000baseT_Full |
154  SUPPORTED_FIBRE |
155  SUPPORTED_Autoneg);
156 
157  ecmd->advertising = (ADVERTISED_1000baseT_Full |
158  ADVERTISED_FIBRE |
159  ADVERTISED_Autoneg);
160 
161  ecmd->port = PORT_FIBRE;
162  ecmd->transceiver = XCVR_EXTERNAL;
163  }
164 
165  speed = -1;
166  ecmd->duplex = -1;
167 
168  if (netif_running(netdev)) {
169  if (netif_carrier_ok(netdev)) {
170  speed = adapter->link_speed;
171  ecmd->duplex = adapter->link_duplex - 1;
172  }
173  } else {
174  u32 status = er32(STATUS);
175  if (status & E1000_STATUS_LU) {
176  if (status & E1000_STATUS_SPEED_1000)
177  speed = SPEED_1000;
178  else if (status & E1000_STATUS_SPEED_100)
179  speed = SPEED_100;
180  else
181  speed = SPEED_10;
182 
183  if (status & E1000_STATUS_FD)
184  ecmd->duplex = DUPLEX_FULL;
185  else
186  ecmd->duplex = DUPLEX_HALF;
187  }
188  }
189 
190  ethtool_cmd_speed_set(ecmd, speed);
191  ecmd->autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||
192  hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
193 
194  /* MDI-X => 2; MDI =>1; Invalid =>0 */
195  if ((hw->phy.media_type == e1000_media_type_copper) &&
196  netif_carrier_ok(netdev))
197  ecmd->eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X :
198  ETH_TP_MDI;
199  else
200  ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID;
201 
202  if (hw->phy.mdix == AUTO_ALL_MODES)
203  ecmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
204  else
205  ecmd->eth_tp_mdix_ctrl = hw->phy.mdix;
206 
207  return 0;
208 }
209 
210 static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
211 {
212  struct e1000_mac_info *mac = &adapter->hw.mac;
213 
214  mac->autoneg = 0;
215 
216  /* Make sure dplx is at most 1 bit and lsb of speed is not set
217  * for the switch() below to work */
218  if ((spd & 1) || (dplx & ~1))
219  goto err_inval;
220 
221  /* Fiber NICs only allow 1000 gbps Full duplex */
222  if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
223  spd != SPEED_1000 &&
224  dplx != DUPLEX_FULL) {
225  goto err_inval;
226  }
227 
228  switch (spd + dplx) {
229  case SPEED_10 + DUPLEX_HALF:
230  mac->forced_speed_duplex = ADVERTISE_10_HALF;
231  break;
232  case SPEED_10 + DUPLEX_FULL:
233  mac->forced_speed_duplex = ADVERTISE_10_FULL;
234  break;
235  case SPEED_100 + DUPLEX_HALF:
236  mac->forced_speed_duplex = ADVERTISE_100_HALF;
237  break;
238  case SPEED_100 + DUPLEX_FULL:
239  mac->forced_speed_duplex = ADVERTISE_100_FULL;
240  break;
241  case SPEED_1000 + DUPLEX_FULL:
242  mac->autoneg = 1;
243  adapter->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL;
244  break;
245  case SPEED_1000 + DUPLEX_HALF: /* not supported */
246  default:
247  goto err_inval;
248  }
249 
250  /* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
251  adapter->hw.phy.mdix = AUTO_ALL_MODES;
252 
253  return 0;
254 
255 err_inval:
256  e_err("Unsupported Speed/Duplex configuration\n");
257  return -EINVAL;
258 }
259 
260 static int e1000_set_settings(struct net_device *netdev,
261  struct ethtool_cmd *ecmd)
262 {
263  struct e1000_adapter *adapter = netdev_priv(netdev);
264  struct e1000_hw *hw = &adapter->hw;
265 
266  /*
267  * When SoL/IDER sessions are active, autoneg/speed/duplex
268  * cannot be changed
269  */
270  if (hw->phy.ops.check_reset_block &&
271  hw->phy.ops.check_reset_block(hw)) {
272  e_err("Cannot change link characteristics when SoL/IDER is active.\n");
273  return -EINVAL;
274  }
275 
276  /*
277  * MDI setting is only allowed when autoneg enabled because
278  * some hardware doesn't allow MDI setting when speed or
279  * duplex is forced.
280  */
281  if (ecmd->eth_tp_mdix_ctrl) {
282  if (hw->phy.media_type != e1000_media_type_copper)
283  return -EOPNOTSUPP;
284 
285  if ((ecmd->eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
286  (ecmd->autoneg != AUTONEG_ENABLE)) {
287  e_err("forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
288  return -EINVAL;
289  }
290  }
291 
292  while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
293  usleep_range(1000, 2000);
294 
295  if (ecmd->autoneg == AUTONEG_ENABLE) {
296  hw->mac.autoneg = 1;
297  if (hw->phy.media_type == e1000_media_type_fiber)
298  hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |
299  ADVERTISED_FIBRE |
300  ADVERTISED_Autoneg;
301  else
302  hw->phy.autoneg_advertised = ecmd->advertising |
303  ADVERTISED_TP |
304  ADVERTISED_Autoneg;
305  ecmd->advertising = hw->phy.autoneg_advertised;
306  if (adapter->fc_autoneg)
307  hw->fc.requested_mode = e1000_fc_default;
308  } else {
309  u32 speed = ethtool_cmd_speed(ecmd);
310  /* calling this overrides forced MDI setting */
311  if (e1000_set_spd_dplx(adapter, speed, ecmd->duplex)) {
312  clear_bit(__E1000_RESETTING, &adapter->state);
313  return -EINVAL;
314  }
315  }
316 
317  /* MDI-X => 2; MDI => 1; Auto => 3 */
318  if (ecmd->eth_tp_mdix_ctrl) {
319  /*
320  * fix up the value for auto (3 => 0) as zero is mapped
321  * internally to auto
322  */
323  if (ecmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
324  hw->phy.mdix = AUTO_ALL_MODES;
325  else
326  hw->phy.mdix = ecmd->eth_tp_mdix_ctrl;
327  }
328 
329  /* reset the link */
330 
331  if (netif_running(adapter->netdev)) {
332  e1000e_down(adapter);
333  e1000e_up(adapter);
334  } else
335  e1000e_reset(adapter);
336 
337  clear_bit(__E1000_RESETTING, &adapter->state);
338  return 0;
339 }
340 
341 static void e1000_get_pauseparam(struct net_device *netdev,
342  struct ethtool_pauseparam *pause)
343 {
344  struct e1000_adapter *adapter = netdev_priv(netdev);
345  struct e1000_hw *hw = &adapter->hw;
346 
347  pause->autoneg =
348  (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
349 
350  if (hw->fc.current_mode == e1000_fc_rx_pause) {
351  pause->rx_pause = 1;
352  } else if (hw->fc.current_mode == e1000_fc_tx_pause) {
353  pause->tx_pause = 1;
354  } else if (hw->fc.current_mode == e1000_fc_full) {
355  pause->rx_pause = 1;
356  pause->tx_pause = 1;
357  }
358 }
359 
360 static int e1000_set_pauseparam(struct net_device *netdev,
361  struct ethtool_pauseparam *pause)
362 {
363  struct e1000_adapter *adapter = netdev_priv(netdev);
364  struct e1000_hw *hw = &adapter->hw;
365  int retval = 0;
366 
367  adapter->fc_autoneg = pause->autoneg;
368 
369  while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
370  usleep_range(1000, 2000);
371 
372  if (adapter->fc_autoneg == AUTONEG_ENABLE) {
373  hw->fc.requested_mode = e1000_fc_default;
374  if (netif_running(adapter->netdev)) {
375  e1000e_down(adapter);
376  e1000e_up(adapter);
377  } else {
378  e1000e_reset(adapter);
379  }
380  } else {
381  if (pause->rx_pause && pause->tx_pause)
382  hw->fc.requested_mode = e1000_fc_full;
383  else if (pause->rx_pause && !pause->tx_pause)
384  hw->fc.requested_mode = e1000_fc_rx_pause;
385  else if (!pause->rx_pause && pause->tx_pause)
386  hw->fc.requested_mode = e1000_fc_tx_pause;
387  else if (!pause->rx_pause && !pause->tx_pause)
388  hw->fc.requested_mode = e1000_fc_none;
389 
390  hw->fc.current_mode = hw->fc.requested_mode;
391 
392  if (hw->phy.media_type == e1000_media_type_fiber) {
393  retval = hw->mac.ops.setup_link(hw);
394  /* implicit goto out */
395  } else {
396  retval = e1000e_force_mac_fc(hw);
397  if (retval)
398  goto out;
399  e1000e_set_fc_watermarks(hw);
400  }
401  }
402 
403 out:
404  clear_bit(__E1000_RESETTING, &adapter->state);
405  return retval;
406 }
407 
408 static u32 e1000_get_msglevel(struct net_device *netdev)
409 {
410  struct e1000_adapter *adapter = netdev_priv(netdev);
411  return adapter->msg_enable;
412 }
413 
414 static void e1000_set_msglevel(struct net_device *netdev, u32 data)
415 {
416  struct e1000_adapter *adapter = netdev_priv(netdev);
417  adapter->msg_enable = data;
418 }
419 
420 static int e1000_get_regs_len(struct net_device *netdev)
421 {
422 #define E1000_REGS_LEN 32 /* overestimate */
423  return E1000_REGS_LEN * sizeof(u32);
424 }
425 
426 static void e1000_get_regs(struct net_device *netdev,
427  struct ethtool_regs *regs, void *p)
428 {
429  struct e1000_adapter *adapter = netdev_priv(netdev);
430  struct e1000_hw *hw = &adapter->hw;
431  u32 *regs_buff = p;
432  u16 phy_data;
433 
434  memset(p, 0, E1000_REGS_LEN * sizeof(u32));
435 
436  regs->version = (1 << 24) | (adapter->pdev->revision << 16) |
437  adapter->pdev->device;
438 
439  regs_buff[0] = er32(CTRL);
440  regs_buff[1] = er32(STATUS);
441 
442  regs_buff[2] = er32(RCTL);
443  regs_buff[3] = er32(RDLEN(0));
444  regs_buff[4] = er32(RDH(0));
445  regs_buff[5] = er32(RDT(0));
446  regs_buff[6] = er32(RDTR);
447 
448  regs_buff[7] = er32(TCTL);
449  regs_buff[8] = er32(TDLEN(0));
450  regs_buff[9] = er32(TDH(0));
451  regs_buff[10] = er32(TDT(0));
452  regs_buff[11] = er32(TIDV);
453 
454  regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */
455 
456  /* ethtool doesn't use anything past this point, so all this
457  * code is likely legacy junk for apps that may or may not
458  * exist */
459  if (hw->phy.type == e1000_phy_m88) {
460  e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
461  regs_buff[13] = (u32)phy_data; /* cable length */
462  regs_buff[14] = 0; /* Dummy (to align w/ IGP phy reg dump) */
463  regs_buff[15] = 0; /* Dummy (to align w/ IGP phy reg dump) */
464  regs_buff[16] = 0; /* Dummy (to align w/ IGP phy reg dump) */
465  e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
466  regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
467  regs_buff[18] = regs_buff[13]; /* cable polarity */
468  regs_buff[19] = 0; /* Dummy (to align w/ IGP phy reg dump) */
469  regs_buff[20] = regs_buff[17]; /* polarity correction */
470  /* phy receive errors */
471  regs_buff[22] = adapter->phy_stats.receive_errors;
472  regs_buff[23] = regs_buff[13]; /* mdix mode */
473  }
474  regs_buff[21] = 0; /* was idle_errors */
475  e1e_rphy(hw, PHY_1000T_STATUS, &phy_data);
476  regs_buff[24] = (u32)phy_data; /* phy local receiver status */
477  regs_buff[25] = regs_buff[24]; /* phy remote receiver status */
478 }
479 
480 static int e1000_get_eeprom_len(struct net_device *netdev)
481 {
482  struct e1000_adapter *adapter = netdev_priv(netdev);
483  return adapter->hw.nvm.word_size * 2;
484 }
485 
486 static int e1000_get_eeprom(struct net_device *netdev,
487  struct ethtool_eeprom *eeprom, u8 *bytes)
488 {
489  struct e1000_adapter *adapter = netdev_priv(netdev);
490  struct e1000_hw *hw = &adapter->hw;
491  u16 *eeprom_buff;
492  int first_word;
493  int last_word;
494  int ret_val = 0;
495  u16 i;
496 
497  if (eeprom->len == 0)
498  return -EINVAL;
499 
500  eeprom->magic = adapter->pdev->vendor | (adapter->pdev->device << 16);
501 
502  first_word = eeprom->offset >> 1;
503  last_word = (eeprom->offset + eeprom->len - 1) >> 1;
504 
505  eeprom_buff = kmalloc(sizeof(u16) *
506  (last_word - first_word + 1), GFP_KERNEL);
507  if (!eeprom_buff)
508  return -ENOMEM;
509 
510  if (hw->nvm.type == e1000_nvm_eeprom_spi) {
511  ret_val = e1000_read_nvm(hw, first_word,
512  last_word - first_word + 1,
513  eeprom_buff);
514  } else {
515  for (i = 0; i < last_word - first_word + 1; i++) {
516  ret_val = e1000_read_nvm(hw, first_word + i, 1,
517  &eeprom_buff[i]);
518  if (ret_val)
519  break;
520  }
521  }
522 
523  if (ret_val) {
524  /* a read error occurred, throw away the result */
525  memset(eeprom_buff, 0xff, sizeof(u16) *
526  (last_word - first_word + 1));
527  } else {
528  /* Device's eeprom is always little-endian, word addressable */
529  for (i = 0; i < last_word - first_word + 1; i++)
530  le16_to_cpus(&eeprom_buff[i]);
531  }
532 
533  memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
534  kfree(eeprom_buff);
535 
536  return ret_val;
537 }
538 
539 static int e1000_set_eeprom(struct net_device *netdev,
540  struct ethtool_eeprom *eeprom, u8 *bytes)
541 {
542  struct e1000_adapter *adapter = netdev_priv(netdev);
543  struct e1000_hw *hw = &adapter->hw;
544  u16 *eeprom_buff;
545  void *ptr;
546  int max_len;
547  int first_word;
548  int last_word;
549  int ret_val = 0;
550  u16 i;
551 
552  if (eeprom->len == 0)
553  return -EOPNOTSUPP;
554 
555  if (eeprom->magic != (adapter->pdev->vendor | (adapter->pdev->device << 16)))
556  return -EFAULT;
557 
558  if (adapter->flags & FLAG_READ_ONLY_NVM)
559  return -EINVAL;
560 
561  max_len = hw->nvm.word_size * 2;
562 
563  first_word = eeprom->offset >> 1;
564  last_word = (eeprom->offset + eeprom->len - 1) >> 1;
565  eeprom_buff = kmalloc(max_len, GFP_KERNEL);
566  if (!eeprom_buff)
567  return -ENOMEM;
568 
569  ptr = (void *)eeprom_buff;
570 
571  if (eeprom->offset & 1) {
572  /* need read/modify/write of first changed EEPROM word */
573  /* only the second byte of the word is being modified */
574  ret_val = e1000_read_nvm(hw, first_word, 1, &eeprom_buff[0]);
575  ptr++;
576  }
577  if (((eeprom->offset + eeprom->len) & 1) && (!ret_val))
578  /* need read/modify/write of last changed EEPROM word */
579  /* only the first byte of the word is being modified */
580  ret_val = e1000_read_nvm(hw, last_word, 1,
581  &eeprom_buff[last_word - first_word]);
582 
583  if (ret_val)
584  goto out;
585 
586  /* Device's eeprom is always little-endian, word addressable */
587  for (i = 0; i < last_word - first_word + 1; i++)
588  le16_to_cpus(&eeprom_buff[i]);
589 
590  memcpy(ptr, bytes, eeprom->len);
591 
592  for (i = 0; i < last_word - first_word + 1; i++)
593  cpu_to_le16s(&eeprom_buff[i]);
594 
595  ret_val = e1000_write_nvm(hw, first_word,
596  last_word - first_word + 1, eeprom_buff);
597 
598  if (ret_val)
599  goto out;
600 
601  /*
602  * Update the checksum over the first part of the EEPROM if needed
603  * and flush shadow RAM for applicable controllers
604  */
605  if ((first_word <= NVM_CHECKSUM_REG) ||
606  (hw->mac.type == e1000_82583) ||
607  (hw->mac.type == e1000_82574) ||
608  (hw->mac.type == e1000_82573))
609  ret_val = e1000e_update_nvm_checksum(hw);
610 
611 out:
612  kfree(eeprom_buff);
613  return ret_val;
614 }
615 
616 static void e1000_get_drvinfo(struct net_device *netdev,
617  struct ethtool_drvinfo *drvinfo)
618 {
619  struct e1000_adapter *adapter = netdev_priv(netdev);
620 
621  strlcpy(drvinfo->driver, e1000e_driver_name,
622  sizeof(drvinfo->driver));
623  strlcpy(drvinfo->version, e1000e_driver_version,
624  sizeof(drvinfo->version));
625 
626  /*
627  * EEPROM image version # is reported as firmware version # for
628  * PCI-E controllers
629  */
630  snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
631  "%d.%d-%d",
632  (adapter->eeprom_vers & 0xF000) >> 12,
633  (adapter->eeprom_vers & 0x0FF0) >> 4,
634  (adapter->eeprom_vers & 0x000F));
635 
636  strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
637  sizeof(drvinfo->bus_info));
638  drvinfo->regdump_len = e1000_get_regs_len(netdev);
639  drvinfo->eedump_len = e1000_get_eeprom_len(netdev);
640 }
641 
642 static void e1000_get_ringparam(struct net_device *netdev,
643  struct ethtool_ringparam *ring)
644 {
645  struct e1000_adapter *adapter = netdev_priv(netdev);
646 
647  ring->rx_max_pending = E1000_MAX_RXD;
648  ring->tx_max_pending = E1000_MAX_TXD;
649  ring->rx_pending = adapter->rx_ring_count;
650  ring->tx_pending = adapter->tx_ring_count;
651 }
652 
653 static int e1000_set_ringparam(struct net_device *netdev,
654  struct ethtool_ringparam *ring)
655 {
656  struct e1000_adapter *adapter = netdev_priv(netdev);
657  struct e1000_ring *temp_tx = NULL, *temp_rx = NULL;
658  int err = 0, size = sizeof(struct e1000_ring);
659  bool set_tx = false, set_rx = false;
660  u16 new_rx_count, new_tx_count;
661 
662  if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
663  return -EINVAL;
664 
665  new_rx_count = clamp_t(u32, ring->rx_pending, E1000_MIN_RXD,
666  E1000_MAX_RXD);
667  new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
668 
669  new_tx_count = clamp_t(u32, ring->tx_pending, E1000_MIN_TXD,
670  E1000_MAX_TXD);
671  new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
672 
673  if ((new_tx_count == adapter->tx_ring_count) &&
674  (new_rx_count == adapter->rx_ring_count))
675  /* nothing to do */
676  return 0;
677 
678  while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
679  usleep_range(1000, 2000);
680 
681  if (!netif_running(adapter->netdev)) {
682  /* Set counts now and allocate resources during open() */
683  adapter->tx_ring->count = new_tx_count;
684  adapter->rx_ring->count = new_rx_count;
685  adapter->tx_ring_count = new_tx_count;
686  adapter->rx_ring_count = new_rx_count;
687  goto clear_reset;
688  }
689 
690  set_tx = (new_tx_count != adapter->tx_ring_count);
691  set_rx = (new_rx_count != adapter->rx_ring_count);
692 
693  /* Allocate temporary storage for ring updates */
694  if (set_tx) {
695  temp_tx = vmalloc(size);
696  if (!temp_tx) {
697  err = -ENOMEM;
698  goto free_temp;
699  }
700  }
701  if (set_rx) {
702  temp_rx = vmalloc(size);
703  if (!temp_rx) {
704  err = -ENOMEM;
705  goto free_temp;
706  }
707  }
708 
709  e1000e_down(adapter);
710 
711  /*
712  * We can't just free everything and then setup again, because the
713  * ISRs in MSI-X mode get passed pointers to the Tx and Rx ring
714  * structs. First, attempt to allocate new resources...
715  */
716  if (set_tx) {
717  memcpy(temp_tx, adapter->tx_ring, size);
718  temp_tx->count = new_tx_count;
719  err = e1000e_setup_tx_resources(temp_tx);
720  if (err)
721  goto err_setup;
722  }
723  if (set_rx) {
724  memcpy(temp_rx, adapter->rx_ring, size);
725  temp_rx->count = new_rx_count;
726  err = e1000e_setup_rx_resources(temp_rx);
727  if (err)
728  goto err_setup_rx;
729  }
730 
731  /* ...then free the old resources and copy back any new ring data */
732  if (set_tx) {
733  e1000e_free_tx_resources(adapter->tx_ring);
734  memcpy(adapter->tx_ring, temp_tx, size);
735  adapter->tx_ring_count = new_tx_count;
736  }
737  if (set_rx) {
738  e1000e_free_rx_resources(adapter->rx_ring);
739  memcpy(adapter->rx_ring, temp_rx, size);
740  adapter->rx_ring_count = new_rx_count;
741  }
742 
743 err_setup_rx:
744  if (err && set_tx)
745  e1000e_free_tx_resources(temp_tx);
746 err_setup:
747  e1000e_up(adapter);
748 free_temp:
749  vfree(temp_tx);
750  vfree(temp_rx);
751 clear_reset:
752  clear_bit(__E1000_RESETTING, &adapter->state);
753  return err;
754 }
755 
756 static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
757  int reg, int offset, u32 mask, u32 write)
758 {
759  u32 pat, val;
760  static const u32 test[] = {
761  0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};
762  for (pat = 0; pat < ARRAY_SIZE(test); pat++) {
763  E1000_WRITE_REG_ARRAY(&adapter->hw, reg, offset,
764  (test[pat] & write));
765  val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset);
766  if (val != (test[pat] & write & mask)) {
767  e_err("pattern test reg %04X failed: got 0x%08X expected 0x%08X\n",
768  reg + offset, val, (test[pat] & write & mask));
769  *data = reg;
770  return 1;
771  }
772  }
773  return 0;
774 }
775 
776 static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,
777  int reg, u32 mask, u32 write)
778 {
779  u32 val;
780  __ew32(&adapter->hw, reg, write & mask);
781  val = __er32(&adapter->hw, reg);
782  if ((write & mask) != (val & mask)) {
783  e_err("set/check reg %04X test failed: got 0x%08X expected 0x%08X\n",
784  reg, (val & mask), (write & mask));
785  *data = reg;
786  return 1;
787  }
788  return 0;
789 }
790 #define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write) \
791  do { \
792  if (reg_pattern_test(adapter, data, reg, offset, mask, write)) \
793  return 1; \
794  } while (0)
795 #define REG_PATTERN_TEST(reg, mask, write) \
796  REG_PATTERN_TEST_ARRAY(reg, 0, mask, write)
797 
798 #define REG_SET_AND_CHECK(reg, mask, write) \
799  do { \
800  if (reg_set_and_check(adapter, data, reg, mask, write)) \
801  return 1; \
802  } while (0)
803 
804 static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
805 {
806  struct e1000_hw *hw = &adapter->hw;
807  struct e1000_mac_info *mac = &adapter->hw.mac;
808  u32 value;
809  u32 before;
810  u32 after;
811  u32 i;
812  u32 toggle;
813  u32 mask;
814  u32 wlock_mac = 0;
815 
816  /*
817  * The status register is Read Only, so a write should fail.
818  * Some bits that get toggled are ignored.
819  */
820  switch (mac->type) {
821  /* there are several bits on newer hardware that are r/w */
822  case e1000_82571:
823  case e1000_82572:
824  case e1000_80003es2lan:
825  toggle = 0x7FFFF3FF;
826  break;
827  default:
828  toggle = 0x7FFFF033;
829  break;
830  }
831 
832  before = er32(STATUS);
833  value = (er32(STATUS) & toggle);
834  ew32(STATUS, toggle);
835  after = er32(STATUS) & toggle;
836  if (value != after) {
837  e_err("failed STATUS register test got: 0x%08X expected: 0x%08X\n",
838  after, value);
839  *data = 1;
840  return 1;
841  }
842  /* restore previous status */
843  ew32(STATUS, before);
844 
845  if (!(adapter->flags & FLAG_IS_ICH)) {
846  REG_PATTERN_TEST(E1000_FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
847  REG_PATTERN_TEST(E1000_FCAH, 0x0000FFFF, 0xFFFFFFFF);
848  REG_PATTERN_TEST(E1000_FCT, 0x0000FFFF, 0xFFFFFFFF);
849  REG_PATTERN_TEST(E1000_VET, 0x0000FFFF, 0xFFFFFFFF);
850  }
851 
852  REG_PATTERN_TEST(E1000_RDTR, 0x0000FFFF, 0xFFFFFFFF);
853  REG_PATTERN_TEST(E1000_RDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
854  REG_PATTERN_TEST(E1000_RDLEN(0), 0x000FFF80, 0x000FFFFF);
855  REG_PATTERN_TEST(E1000_RDH(0), 0x0000FFFF, 0x0000FFFF);
856  REG_PATTERN_TEST(E1000_RDT(0), 0x0000FFFF, 0x0000FFFF);
857  REG_PATTERN_TEST(E1000_FCRTH, 0x0000FFF8, 0x0000FFF8);
858  REG_PATTERN_TEST(E1000_FCTTV, 0x0000FFFF, 0x0000FFFF);
859  REG_PATTERN_TEST(E1000_TIPG, 0x3FFFFFFF, 0x3FFFFFFF);
860  REG_PATTERN_TEST(E1000_TDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
861  REG_PATTERN_TEST(E1000_TDLEN(0), 0x000FFF80, 0x000FFFFF);
862 
863  REG_SET_AND_CHECK(E1000_RCTL, 0xFFFFFFFF, 0x00000000);
864 
865  before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE);
866  REG_SET_AND_CHECK(E1000_RCTL, before, 0x003FFFFB);
867  REG_SET_AND_CHECK(E1000_TCTL, 0xFFFFFFFF, 0x00000000);
868 
869  REG_SET_AND_CHECK(E1000_RCTL, before, 0xFFFFFFFF);
870  REG_PATTERN_TEST(E1000_RDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
871  if (!(adapter->flags & FLAG_IS_ICH))
872  REG_PATTERN_TEST(E1000_TXCW, 0xC000FFFF, 0x0000FFFF);
873  REG_PATTERN_TEST(E1000_TDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
874  REG_PATTERN_TEST(E1000_TIDV, 0x0000FFFF, 0x0000FFFF);
875  mask = 0x8003FFFF;
876  switch (mac->type) {
877  case e1000_ich10lan:
878  case e1000_pchlan:
879  case e1000_pch2lan:
880  case e1000_pch_lpt:
881  mask |= (1 << 18);
882  break;
883  default:
884  break;
885  }
886 
887  if (mac->type == e1000_pch_lpt)
888  wlock_mac = (er32(FWSM) & E1000_FWSM_WLOCK_MAC_MASK) >>
889  E1000_FWSM_WLOCK_MAC_SHIFT;
890 
891  for (i = 0; i < mac->rar_entry_count; i++) {
892  /* Cannot test write-protected SHRAL[n] registers */
893  if ((wlock_mac == 1) || (wlock_mac && (i > wlock_mac)))
894  continue;
895 
896  REG_PATTERN_TEST_ARRAY(E1000_RA, ((i << 1) + 1),
897  mask, 0xFFFFFFFF);
898  }
899 
900  for (i = 0; i < mac->mta_reg_count; i++)
901  REG_PATTERN_TEST_ARRAY(E1000_MTA, i, 0xFFFFFFFF, 0xFFFFFFFF);
902 
903  *data = 0;
904 
905  return 0;
906 }
907 
908 static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
909 {
910  u16 temp;
911  u16 checksum = 0;
912  u16 i;
913 
914  *data = 0;
915  /* Read and add up the contents of the EEPROM */
916  for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
917  if ((e1000_read_nvm(&adapter->hw, i, 1, &temp)) < 0) {
918  *data = 1;
919  return *data;
920  }
921  checksum += temp;
922  }
923 
924  /* If Checksum is not Correct return error else test passed */
925  if ((checksum != (u16) NVM_SUM) && !(*data))
926  *data = 2;
927 
928  return *data;
929 }
930 
931 static irqreturn_t e1000_test_intr(int irq, void *data)
932 {
933  struct net_device *netdev = (struct net_device *) data;
934  struct e1000_adapter *adapter = netdev_priv(netdev);
935  struct e1000_hw *hw = &adapter->hw;
936 
937  adapter->test_icr |= er32(ICR);
938 
939  return IRQ_HANDLED;
940 }
941 
942 static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
943 {
944  struct net_device *netdev = adapter->netdev;
945  struct e1000_hw *hw = &adapter->hw;
946  u32 mask;
947  u32 shared_int = 1;
948  u32 irq = adapter->pdev->irq;
949  int i;
950  int ret_val = 0;
951  int int_mode = E1000E_INT_MODE_LEGACY;
952 
953  *data = 0;
954 
955  /* NOTE: we don't test MSI/MSI-X interrupts here, yet */
956  if (adapter->int_mode == E1000E_INT_MODE_MSIX) {
957  int_mode = adapter->int_mode;
958  e1000e_reset_interrupt_capability(adapter);
959  adapter->int_mode = E1000E_INT_MODE_LEGACY;
960  e1000e_set_interrupt_capability(adapter);
961  }
962  /* Hook up test interrupt handler just for this test */
963  if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
964  netdev)) {
965  shared_int = 0;
966  } else if (request_irq(irq, e1000_test_intr, IRQF_SHARED,
967  netdev->name, netdev)) {
968  *data = 1;
969  ret_val = -1;
970  goto out;
971  }
972  e_info("testing %s interrupt\n", (shared_int ? "shared" : "unshared"));
973 
974  /* Disable all the interrupts */
975  ew32(IMC, 0xFFFFFFFF);
976  e1e_flush();
977  usleep_range(10000, 20000);
978 
979  /* Test each interrupt */
980  for (i = 0; i < 10; i++) {
981  /* Interrupt to test */
982  mask = 1 << i;
983 
984  if (adapter->flags & FLAG_IS_ICH) {
985  switch (mask) {
986  case E1000_ICR_RXSEQ:
987  continue;
988  case 0x00000100:
989  if (adapter->hw.mac.type == e1000_ich8lan ||
990  adapter->hw.mac.type == e1000_ich9lan)
991  continue;
992  break;
993  default:
994  break;
995  }
996  }
997 
998  if (!shared_int) {
999  /*
1000  * Disable the interrupt to be reported in
1001  * the cause register and then force the same
1002  * interrupt and see if one gets posted. If
1003  * an interrupt was posted to the bus, the
1004  * test failed.
1005  */
1006  adapter->test_icr = 0;
1007  ew32(IMC, mask);
1008  ew32(ICS, mask);
1009  e1e_flush();
1010  usleep_range(10000, 20000);
1011 
1012  if (adapter->test_icr & mask) {
1013  *data = 3;
1014  break;
1015  }
1016  }
1017 
1018  /*
1019  * Enable the interrupt to be reported in
1020  * the cause register and then force the same
1021  * interrupt and see if one gets posted. If
1022  * an interrupt was not posted to the bus, the
1023  * test failed.
1024  */
1025  adapter->test_icr = 0;
1026  ew32(IMS, mask);
1027  ew32(ICS, mask);
1028  e1e_flush();
1029  usleep_range(10000, 20000);
1030 
1031  if (!(adapter->test_icr & mask)) {
1032  *data = 4;
1033  break;
1034  }
1035 
1036  if (!shared_int) {
1037  /*
1038  * Disable the other interrupts to be reported in
1039  * the cause register and then force the other
1040  * interrupts and see if any get posted. If
1041  * an interrupt was posted to the bus, the
1042  * test failed.
1043  */
1044  adapter->test_icr = 0;
1045  ew32(IMC, ~mask & 0x00007FFF);
1046  ew32(ICS, ~mask & 0x00007FFF);
1047  e1e_flush();
1048  usleep_range(10000, 20000);
1049 
1050  if (adapter->test_icr) {
1051  *data = 5;
1052  break;
1053  }
1054  }
1055  }
1056 
1057  /* Disable all the interrupts */
1058  ew32(IMC, 0xFFFFFFFF);
1059  e1e_flush();
1060  usleep_range(10000, 20000);
1061 
1062  /* Unhook test interrupt handler */
1063  free_irq(irq, netdev);
1064 
1065 out:
1066  if (int_mode == E1000E_INT_MODE_MSIX) {
1067  e1000e_reset_interrupt_capability(adapter);
1068  adapter->int_mode = int_mode;
1069  e1000e_set_interrupt_capability(adapter);
1070  }
1071 
1072  return ret_val;
1073 }
1074 
1075 static void e1000_free_desc_rings(struct e1000_adapter *adapter)
1076 {
1077  struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1078  struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1079  struct pci_dev *pdev = adapter->pdev;
1080  int i;
1081 
1082  if (tx_ring->desc && tx_ring->buffer_info) {
1083  for (i = 0; i < tx_ring->count; i++) {
1084  if (tx_ring->buffer_info[i].dma)
1085  dma_unmap_single(&pdev->dev,
1086  tx_ring->buffer_info[i].dma,
1087  tx_ring->buffer_info[i].length,
1088  DMA_TO_DEVICE);
1089  if (tx_ring->buffer_info[i].skb)
1090  dev_kfree_skb(tx_ring->buffer_info[i].skb);
1091  }
1092  }
1093 
1094  if (rx_ring->desc && rx_ring->buffer_info) {
1095  for (i = 0; i < rx_ring->count; i++) {
1096  if (rx_ring->buffer_info[i].dma)
1097  dma_unmap_single(&pdev->dev,
1098  rx_ring->buffer_info[i].dma,
1099  2048, DMA_FROM_DEVICE);
1100  if (rx_ring->buffer_info[i].skb)
1101  dev_kfree_skb(rx_ring->buffer_info[i].skb);
1102  }
1103  }
1104 
1105  if (tx_ring->desc) {
1106  dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
1107  tx_ring->dma);
1108  tx_ring->desc = NULL;
1109  }
1110  if (rx_ring->desc) {
1111  dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
1112  rx_ring->dma);
1113  rx_ring->desc = NULL;
1114  }
1115 
1116  kfree(tx_ring->buffer_info);
1117  tx_ring->buffer_info = NULL;
1118  kfree(rx_ring->buffer_info);
1119  rx_ring->buffer_info = NULL;
1120 }
1121 
1122 static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
1123 {
1124  struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1125  struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1126  struct pci_dev *pdev = adapter->pdev;
1127  struct e1000_hw *hw = &adapter->hw;
1128  u32 rctl;
1129  int i;
1130  int ret_val;
1131 
1132  /* Setup Tx descriptor ring and Tx buffers */
1133 
1134  if (!tx_ring->count)
1135  tx_ring->count = E1000_DEFAULT_TXD;
1136 
1137  tx_ring->buffer_info = kcalloc(tx_ring->count,
1138  sizeof(struct e1000_buffer),
1139  GFP_KERNEL);
1140  if (!tx_ring->buffer_info) {
1141  ret_val = 1;
1142  goto err_nomem;
1143  }
1144 
1145  tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc);
1146  tx_ring->size = ALIGN(tx_ring->size, 4096);
1147  tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size,
1148  &tx_ring->dma, GFP_KERNEL);
1149  if (!tx_ring->desc) {
1150  ret_val = 2;
1151  goto err_nomem;
1152  }
1153  tx_ring->next_to_use = 0;
1154  tx_ring->next_to_clean = 0;
1155 
1156  ew32(TDBAL(0), ((u64) tx_ring->dma & 0x00000000FFFFFFFF));
1157  ew32(TDBAH(0), ((u64) tx_ring->dma >> 32));
1158  ew32(TDLEN(0), tx_ring->count * sizeof(struct e1000_tx_desc));
1159  ew32(TDH(0), 0);
1160  ew32(TDT(0), 0);
1161  ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | E1000_TCTL_MULR |
1162  E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
1163  E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT);
1164 
1165  for (i = 0; i < tx_ring->count; i++) {
1166  struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
1167  struct sk_buff *skb;
1168  unsigned int skb_size = 1024;
1169 
1170  skb = alloc_skb(skb_size, GFP_KERNEL);
1171  if (!skb) {
1172  ret_val = 3;
1173  goto err_nomem;
1174  }
1175  skb_put(skb, skb_size);
1176  tx_ring->buffer_info[i].skb = skb;
1177  tx_ring->buffer_info[i].length = skb->len;
1178  tx_ring->buffer_info[i].dma =
1179  dma_map_single(&pdev->dev, skb->data, skb->len,
1180  DMA_TO_DEVICE);
1181  if (dma_mapping_error(&pdev->dev,
1182  tx_ring->buffer_info[i].dma)) {
1183  ret_val = 4;
1184  goto err_nomem;
1185  }
1186  tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);
1187  tx_desc->lower.data = cpu_to_le32(skb->len);
1188  tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
1189  E1000_TXD_CMD_IFCS |
1190  E1000_TXD_CMD_RS);
1191  tx_desc->upper.data = 0;
1192  }
1193 
1194  /* Setup Rx descriptor ring and Rx buffers */
1195 
1196  if (!rx_ring->count)
1197  rx_ring->count = E1000_DEFAULT_RXD;
1198 
1199  rx_ring->buffer_info = kcalloc(rx_ring->count,
1200  sizeof(struct e1000_buffer),
1201  GFP_KERNEL);
1202  if (!rx_ring->buffer_info) {
1203  ret_val = 5;
1204  goto err_nomem;
1205  }
1206 
1207  rx_ring->size = rx_ring->count * sizeof(union e1000_rx_desc_extended);
1208  rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,
1209  &rx_ring->dma, GFP_KERNEL);
1210  if (!rx_ring->desc) {
1211  ret_val = 6;
1212  goto err_nomem;
1213  }
1214  rx_ring->next_to_use = 0;
1215  rx_ring->next_to_clean = 0;
1216 
1217  rctl = er32(RCTL);
1218  if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
1219  ew32(RCTL, rctl & ~E1000_RCTL_EN);
1220  ew32(RDBAL(0), ((u64) rx_ring->dma & 0xFFFFFFFF));
1221  ew32(RDBAH(0), ((u64) rx_ring->dma >> 32));
1222  ew32(RDLEN(0), rx_ring->size);
1223  ew32(RDH(0), 0);
1224  ew32(RDT(0), 0);
1225  rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
1226  E1000_RCTL_UPE | E1000_RCTL_MPE | E1000_RCTL_LPE |
1227  E1000_RCTL_SBP | E1000_RCTL_SECRC |
1228  E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1229  (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
1230  ew32(RCTL, rctl);
1231 
1232  for (i = 0; i < rx_ring->count; i++) {
1233  union e1000_rx_desc_extended *rx_desc;
1234  struct sk_buff *skb;
1235 
1236  skb = alloc_skb(2048 + NET_IP_ALIGN, GFP_KERNEL);
1237  if (!skb) {
1238  ret_val = 7;
1239  goto err_nomem;
1240  }
1241  skb_reserve(skb, NET_IP_ALIGN);
1242  rx_ring->buffer_info[i].skb = skb;
1243  rx_ring->buffer_info[i].dma =
1244  dma_map_single(&pdev->dev, skb->data, 2048,
1245  DMA_FROM_DEVICE);
1246  if (dma_mapping_error(&pdev->dev,
1247  rx_ring->buffer_info[i].dma)) {
1248  ret_val = 8;
1249  goto err_nomem;
1250  }
1251  rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
1252  rx_desc->read.buffer_addr =
1253  cpu_to_le64(rx_ring->buffer_info[i].dma);
1254  memset(skb->data, 0x00, skb->len);
1255  }
1256 
1257  return 0;
1258 
1259 err_nomem:
1260  e1000_free_desc_rings(adapter);
1261  return ret_val;
1262 }
1263 
1264 static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
1265 {
1266  /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1267  e1e_wphy(&adapter->hw, 29, 0x001F);
1268  e1e_wphy(&adapter->hw, 30, 0x8FFC);
1269  e1e_wphy(&adapter->hw, 29, 0x001A);
1270  e1e_wphy(&adapter->hw, 30, 0x8FF0);
1271 }
1272 
1273 static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
1274 {
1275  struct e1000_hw *hw = &adapter->hw;
1276  u32 ctrl_reg = 0;
1277  u16 phy_reg = 0;
1278  s32 ret_val = 0;
1279 
1280  hw->mac.autoneg = 0;
1281 
1282  if (hw->phy.type == e1000_phy_ife) {
1283  /* force 100, set loopback */
1284  e1e_wphy(hw, PHY_CONTROL, 0x6100);
1285 
1286  /* Now set up the MAC to the same speed/duplex as the PHY. */
1287  ctrl_reg = er32(CTRL);
1288  ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1289  ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1290  E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1291  E1000_CTRL_SPD_100 |/* Force Speed to 100 */
1292  E1000_CTRL_FD); /* Force Duplex to FULL */
1293 
1294  ew32(CTRL, ctrl_reg);
1295  e1e_flush();
1296  udelay(500);
1297 
1298  return 0;
1299  }
1300 
1301  /* Specific PHY configuration for loopback */
1302  switch (hw->phy.type) {
1303  case e1000_phy_m88:
1304  /* Auto-MDI/MDIX Off */
1305  e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808);
1306  /* reset to update Auto-MDI/MDIX */
1307  e1e_wphy(hw, PHY_CONTROL, 0x9140);
1308  /* autoneg off */
1309  e1e_wphy(hw, PHY_CONTROL, 0x8140);
1310  break;
1311  case e1000_phy_gg82563:
1312  e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC);
1313  break;
1314  case e1000_phy_bm:
1315  /* Set Default MAC Interface speed to 1GB */
1316  e1e_rphy(hw, PHY_REG(2, 21), &phy_reg);
1317  phy_reg &= ~0x0007;
1318  phy_reg |= 0x006;
1319  e1e_wphy(hw, PHY_REG(2, 21), phy_reg);
1320  /* Assert SW reset for above settings to take effect */
1321  e1000e_commit_phy(hw);
1322  mdelay(1);
1323  /* Force Full Duplex */
1324  e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1325  e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x000C);
1326  /* Set Link Up (in force link) */
1327  e1e_rphy(hw, PHY_REG(776, 16), &phy_reg);
1328  e1e_wphy(hw, PHY_REG(776, 16), phy_reg | 0x0040);
1329  /* Force Link */
1330  e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1331  e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x0040);
1332  /* Set Early Link Enable */
1333  e1e_rphy(hw, PHY_REG(769, 20), &phy_reg);
1334  e1e_wphy(hw, PHY_REG(769, 20), phy_reg | 0x0400);
1335  break;
1336  case e1000_phy_82577:
1337  case e1000_phy_82578:
1338  /* Workaround: K1 must be disabled for stable 1Gbps operation */
1339  ret_val = hw->phy.ops.acquire(hw);
1340  if (ret_val) {
1341  e_err("Cannot setup 1Gbps loopback.\n");
1342  return ret_val;
1343  }
1344  e1000_configure_k1_ich8lan(hw, false);
1345  hw->phy.ops.release(hw);
1346  break;
1347  case e1000_phy_82579:
1348  /* Disable PHY energy detect power down */
1349  e1e_rphy(hw, PHY_REG(0, 21), &phy_reg);
1350  e1e_wphy(hw, PHY_REG(0, 21), phy_reg & ~(1 << 3));
1351  /* Disable full chip energy detect */
1352  e1e_rphy(hw, PHY_REG(776, 18), &phy_reg);
1353  e1e_wphy(hw, PHY_REG(776, 18), phy_reg | 1);
1354  /* Enable loopback on the PHY */
1355 #define I82577_PHY_LBK_CTRL 19
1356  e1e_wphy(hw, I82577_PHY_LBK_CTRL, 0x8001);
1357  break;
1358  default:
1359  break;
1360  }
1361 
1362  /* force 1000, set loopback */
1363  e1e_wphy(hw, PHY_CONTROL, 0x4140);
1364  mdelay(250);
1365 
1366  /* Now set up the MAC to the same speed/duplex as the PHY. */
1367  ctrl_reg = er32(CTRL);
1368  ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1369  ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1370  E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1371  E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1372  E1000_CTRL_FD); /* Force Duplex to FULL */
1373 
1374  if (adapter->flags & FLAG_IS_ICH)
1375  ctrl_reg |= E1000_CTRL_SLU; /* Set Link Up */
1376 
1377  if (hw->phy.media_type == e1000_media_type_copper &&
1378  hw->phy.type == e1000_phy_m88) {
1379  ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
1380  } else {
1381  /*
1382  * Set the ILOS bit on the fiber Nic if half duplex link is
1383  * detected.
1384  */
1385  if ((er32(STATUS) & E1000_STATUS_FD) == 0)
1386  ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
1387  }
1388 
1389  ew32(CTRL, ctrl_reg);
1390 
1391  /*
1392  * Disable the receiver on the PHY so when a cable is plugged in, the
1393  * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1394  */
1395  if (hw->phy.type == e1000_phy_m88)
1396  e1000_phy_disable_receiver(adapter);
1397 
1398  udelay(500);
1399 
1400  return 0;
1401 }
1402 
1403 static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter)
1404 {
1405  struct e1000_hw *hw = &adapter->hw;
1406  u32 ctrl = er32(CTRL);
1407  int link = 0;
1408 
1409  /* special requirements for 82571/82572 fiber adapters */
1410 
1411  /*
1412  * jump through hoops to make sure link is up because serdes
1413  * link is hardwired up
1414  */
1415  ctrl |= E1000_CTRL_SLU;
1416  ew32(CTRL, ctrl);
1417 
1418  /* disable autoneg */
1419  ctrl = er32(TXCW);
1420  ctrl &= ~(1 << 31);
1421  ew32(TXCW, ctrl);
1422 
1423  link = (er32(STATUS) & E1000_STATUS_LU);
1424 
1425  if (!link) {
1426  /* set invert loss of signal */
1427  ctrl = er32(CTRL);
1428  ctrl |= E1000_CTRL_ILOS;
1429  ew32(CTRL, ctrl);
1430  }
1431 
1432  /*
1433  * special write to serdes control register to enable SerDes analog
1434  * loopback
1435  */
1436 #define E1000_SERDES_LB_ON 0x410
1437  ew32(SCTL, E1000_SERDES_LB_ON);
1438  e1e_flush();
1439  usleep_range(10000, 20000);
1440 
1441  return 0;
1442 }
1443 
1444 /* only call this for fiber/serdes connections to es2lan */
1445 static int e1000_set_es2lan_mac_loopback(struct e1000_adapter *adapter)
1446 {
1447  struct e1000_hw *hw = &adapter->hw;
1448  u32 ctrlext = er32(CTRL_EXT);
1449  u32 ctrl = er32(CTRL);
1450 
1451  /*
1452  * save CTRL_EXT to restore later, reuse an empty variable (unused
1453  * on mac_type 80003es2lan)
1454  */
1455  adapter->tx_fifo_head = ctrlext;
1456 
1457  /* clear the serdes mode bits, putting the device into mac loopback */
1458  ctrlext &= ~E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
1459  ew32(CTRL_EXT, ctrlext);
1460 
1461  /* force speed to 1000/FD, link up */
1462  ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1463  ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX |
1464  E1000_CTRL_SPD_1000 | E1000_CTRL_FD);
1465  ew32(CTRL, ctrl);
1466 
1467  /* set mac loopback */
1468  ctrl = er32(RCTL);
1469  ctrl |= E1000_RCTL_LBM_MAC;
1470  ew32(RCTL, ctrl);
1471 
1472  /* set testing mode parameters (no need to reset later) */
1473 #define KMRNCTRLSTA_OPMODE (0x1F << 16)
1474 #define KMRNCTRLSTA_OPMODE_1GB_FD_GMII 0x0582
1475  ew32(KMRNCTRLSTA,
1476  (KMRNCTRLSTA_OPMODE | KMRNCTRLSTA_OPMODE_1GB_FD_GMII));
1477 
1478  return 0;
1479 }
1480 
1481 static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
1482 {
1483  struct e1000_hw *hw = &adapter->hw;
1484  u32 rctl;
1485 
1486  if (hw->phy.media_type == e1000_media_type_fiber ||
1487  hw->phy.media_type == e1000_media_type_internal_serdes) {
1488  switch (hw->mac.type) {
1489  case e1000_80003es2lan:
1490  return e1000_set_es2lan_mac_loopback(adapter);
1491  break;
1492  case e1000_82571:
1493  case e1000_82572:
1494  return e1000_set_82571_fiber_loopback(adapter);
1495  break;
1496  default:
1497  rctl = er32(RCTL);
1498  rctl |= E1000_RCTL_LBM_TCVR;
1499  ew32(RCTL, rctl);
1500  return 0;
1501  }
1502  } else if (hw->phy.media_type == e1000_media_type_copper) {
1503  return e1000_integrated_phy_loopback(adapter);
1504  }
1505 
1506  return 7;
1507 }
1508 
1509 static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
1510 {
1511  struct e1000_hw *hw = &adapter->hw;
1512  u32 rctl;
1513  u16 phy_reg;
1514 
1515  rctl = er32(RCTL);
1516  rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1517  ew32(RCTL, rctl);
1518 
1519  switch (hw->mac.type) {
1520  case e1000_80003es2lan:
1521  if (hw->phy.media_type == e1000_media_type_fiber ||
1522  hw->phy.media_type == e1000_media_type_internal_serdes) {
1523  /* restore CTRL_EXT, stealing space from tx_fifo_head */
1524  ew32(CTRL_EXT, adapter->tx_fifo_head);
1525  adapter->tx_fifo_head = 0;
1526  }
1527  /* fall through */
1528  case e1000_82571:
1529  case e1000_82572:
1530  if (hw->phy.media_type == e1000_media_type_fiber ||
1531  hw->phy.media_type == e1000_media_type_internal_serdes) {
1532 #define E1000_SERDES_LB_OFF 0x400
1533  ew32(SCTL, E1000_SERDES_LB_OFF);
1534  e1e_flush();
1535  usleep_range(10000, 20000);
1536  break;
1537  }
1538  /* Fall Through */
1539  default:
1540  hw->mac.autoneg = 1;
1541  if (hw->phy.type == e1000_phy_gg82563)
1542  e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x180);
1543  e1e_rphy(hw, PHY_CONTROL, &phy_reg);
1544  if (phy_reg & MII_CR_LOOPBACK) {
1545  phy_reg &= ~MII_CR_LOOPBACK;
1546  e1e_wphy(hw, PHY_CONTROL, phy_reg);
1547  e1000e_commit_phy(hw);
1548  }
1549  break;
1550  }
1551 }
1552 
1553 static void e1000_create_lbtest_frame(struct sk_buff *skb,
1554  unsigned int frame_size)
1555 {
1556  memset(skb->data, 0xFF, frame_size);
1557  frame_size &= ~1;
1558  memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
1559  memset(&skb->data[frame_size / 2 + 10], 0xBE, 1);
1560  memset(&skb->data[frame_size / 2 + 12], 0xAF, 1);
1561 }
1562 
1563 static int e1000_check_lbtest_frame(struct sk_buff *skb,
1564  unsigned int frame_size)
1565 {
1566  frame_size &= ~1;
1567  if (*(skb->data + 3) == 0xFF)
1568  if ((*(skb->data + frame_size / 2 + 10) == 0xBE) &&
1569  (*(skb->data + frame_size / 2 + 12) == 0xAF))
1570  return 0;
1571  return 13;
1572 }
1573 
1574 static int e1000_run_loopback_test(struct e1000_adapter *adapter)
1575 {
1576  struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1577  struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1578  struct pci_dev *pdev = adapter->pdev;
1579  struct e1000_hw *hw = &adapter->hw;
1580  int i, j, k, l;
1581  int lc;
1582  int good_cnt;
1583  int ret_val = 0;
1584  unsigned long time;
1585 
1586  ew32(RDT(0), rx_ring->count - 1);
1587 
1588  /*
1589  * Calculate the loop count based on the largest descriptor ring
1590  * The idea is to wrap the largest ring a number of times using 64
1591  * send/receive pairs during each loop
1592  */
1593 
1594  if (rx_ring->count <= tx_ring->count)
1595  lc = ((tx_ring->count / 64) * 2) + 1;
1596  else
1597  lc = ((rx_ring->count / 64) * 2) + 1;
1598 
1599  k = 0;
1600  l = 0;
1601  for (j = 0; j <= lc; j++) { /* loop count loop */
1602  for (i = 0; i < 64; i++) { /* send the packets */
1603  e1000_create_lbtest_frame(tx_ring->buffer_info[k].skb,
1604  1024);
1605  dma_sync_single_for_device(&pdev->dev,
1606  tx_ring->buffer_info[k].dma,
1607  tx_ring->buffer_info[k].length,
1608  DMA_TO_DEVICE);
1609  k++;
1610  if (k == tx_ring->count)
1611  k = 0;
1612  }
1613  ew32(TDT(0), k);
1614  e1e_flush();
1615  msleep(200);
1616  time = jiffies; /* set the start time for the receive */
1617  good_cnt = 0;
1618  do { /* receive the sent packets */
1619  dma_sync_single_for_cpu(&pdev->dev,
1620  rx_ring->buffer_info[l].dma, 2048,
1621  DMA_FROM_DEVICE);
1622 
1623  ret_val = e1000_check_lbtest_frame(
1624  rx_ring->buffer_info[l].skb, 1024);
1625  if (!ret_val)
1626  good_cnt++;
1627  l++;
1628  if (l == rx_ring->count)
1629  l = 0;
1630  /*
1631  * time + 20 msecs (200 msecs on 2.4) is more than
1632  * enough time to complete the receives, if it's
1633  * exceeded, break and error off
1634  */
1635  } while ((good_cnt < 64) && !time_after(jiffies, time + 20));
1636  if (good_cnt != 64) {
1637  ret_val = 13; /* ret_val is the same as mis-compare */
1638  break;
1639  }
1640  if (jiffies >= (time + 20)) {
1641  ret_val = 14; /* error code for time out error */
1642  break;
1643  }
1644  } /* end loop count loop */
1645  return ret_val;
1646 }
1647 
1648 static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1649 {
1650  struct e1000_hw *hw = &adapter->hw;
1651 
1652  /*
1653  * PHY loopback cannot be performed if SoL/IDER
1654  * sessions are active
1655  */
1656  if (hw->phy.ops.check_reset_block &&
1657  hw->phy.ops.check_reset_block(hw)) {
1658  e_err("Cannot do PHY loopback test when SoL/IDER is active.\n");
1659  *data = 0;
1660  goto out;
1661  }
1662 
1663  *data = e1000_setup_desc_rings(adapter);
1664  if (*data)
1665  goto out;
1666 
1667  *data = e1000_setup_loopback_test(adapter);
1668  if (*data)
1669  goto err_loopback;
1670 
1671  *data = e1000_run_loopback_test(adapter);
1672  e1000_loopback_cleanup(adapter);
1673 
1674 err_loopback:
1675  e1000_free_desc_rings(adapter);
1676 out:
1677  return *data;
1678 }
1679 
1680 static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1681 {
1682  struct e1000_hw *hw = &adapter->hw;
1683 
1684  *data = 0;
1685  if (hw->phy.media_type == e1000_media_type_internal_serdes) {
1686  int i = 0;
1687  hw->mac.serdes_has_link = false;
1688 
1689  /*
1690  * On some blade server designs, link establishment
1691  * could take as long as 2-3 minutes
1692  */
1693  do {
1694  hw->mac.ops.check_for_link(hw);
1695  if (hw->mac.serdes_has_link)
1696  return *data;
1697  msleep(20);
1698  } while (i++ < 3750);
1699 
1700  *data = 1;
1701  } else {
1702  hw->mac.ops.check_for_link(hw);
1703  if (hw->mac.autoneg)
1704  /*
1705  * On some Phy/switch combinations, link establishment
1706  * can take a few seconds more than expected.
1707  */
1708  msleep(5000);
1709 
1710  if (!(er32(STATUS) & E1000_STATUS_LU))
1711  *data = 1;
1712  }
1713  return *data;
1714 }
1715 
1716 static int e1000e_get_sset_count(struct net_device *netdev, int sset)
1717 {
1718  switch (sset) {
1719  case ETH_SS_TEST:
1720  return E1000_TEST_LEN;
1721  case ETH_SS_STATS:
1722  return E1000_STATS_LEN;
1723  default:
1724  return -EOPNOTSUPP;
1725  }
1726 }
1727 
1728 static void e1000_diag_test(struct net_device *netdev,
1729  struct ethtool_test *eth_test, u64 *data)
1730 {
1731  struct e1000_adapter *adapter = netdev_priv(netdev);
1732  u16 autoneg_advertised;
1733  u8 forced_speed_duplex;
1734  u8 autoneg;
1735  bool if_running = netif_running(netdev);
1736 
1737  set_bit(__E1000_TESTING, &adapter->state);
1738 
1739  if (!if_running) {
1740  /* Get control of and reset hardware */
1741  if (adapter->flags & FLAG_HAS_AMT)
1742  e1000e_get_hw_control(adapter);
1743 
1744  e1000e_power_up_phy(adapter);
1745 
1746  adapter->hw.phy.autoneg_wait_to_complete = 1;
1747  e1000e_reset(adapter);
1748  adapter->hw.phy.autoneg_wait_to_complete = 0;
1749  }
1750 
1751  if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1752  /* Offline tests */
1753 
1754  /* save speed, duplex, autoneg settings */
1755  autoneg_advertised = adapter->hw.phy.autoneg_advertised;
1756  forced_speed_duplex = adapter->hw.mac.forced_speed_duplex;
1757  autoneg = adapter->hw.mac.autoneg;
1758 
1759  e_info("offline testing starting\n");
1760 
1761  if (if_running)
1762  /* indicate we're in test mode */
1763  dev_close(netdev);
1764 
1765  if (e1000_reg_test(adapter, &data[0]))
1766  eth_test->flags |= ETH_TEST_FL_FAILED;
1767 
1768  e1000e_reset(adapter);
1769  if (e1000_eeprom_test(adapter, &data[1]))
1770  eth_test->flags |= ETH_TEST_FL_FAILED;
1771 
1772  e1000e_reset(adapter);
1773  if (e1000_intr_test(adapter, &data[2]))
1774  eth_test->flags |= ETH_TEST_FL_FAILED;
1775 
1776  e1000e_reset(adapter);
1777  if (e1000_loopback_test(adapter, &data[3]))
1778  eth_test->flags |= ETH_TEST_FL_FAILED;
1779 
1780  /* force this routine to wait until autoneg complete/timeout */
1781  adapter->hw.phy.autoneg_wait_to_complete = 1;
1782  e1000e_reset(adapter);
1783  adapter->hw.phy.autoneg_wait_to_complete = 0;
1784 
1785  if (e1000_link_test(adapter, &data[4]))
1786  eth_test->flags |= ETH_TEST_FL_FAILED;
1787 
1788  /* restore speed, duplex, autoneg settings */
1789  adapter->hw.phy.autoneg_advertised = autoneg_advertised;
1790  adapter->hw.mac.forced_speed_duplex = forced_speed_duplex;
1791  adapter->hw.mac.autoneg = autoneg;
1792  e1000e_reset(adapter);
1793 
1794  clear_bit(__E1000_TESTING, &adapter->state);
1795  if (if_running)
1796  dev_open(netdev);
1797  } else {
1798  /* Online tests */
1799 
1800  e_info("online testing starting\n");
1801 
1802  /* register, eeprom, intr and loopback tests not run online */
1803  data[0] = 0;
1804  data[1] = 0;
1805  data[2] = 0;
1806  data[3] = 0;
1807 
1808  if (e1000_link_test(adapter, &data[4]))
1809  eth_test->flags |= ETH_TEST_FL_FAILED;
1810 
1811  clear_bit(__E1000_TESTING, &adapter->state);
1812  }
1813 
1814  if (!if_running) {
1815  e1000e_reset(adapter);
1816 
1817  if (adapter->flags & FLAG_HAS_AMT)
1818  e1000e_release_hw_control(adapter);
1819  }
1820 
1821  msleep_interruptible(4 * 1000);
1822 }
1823 
1824 static void e1000_get_wol(struct net_device *netdev,
1825  struct ethtool_wolinfo *wol)
1826 {
1827  struct e1000_adapter *adapter = netdev_priv(netdev);
1828 
1829  wol->supported = 0;
1830  wol->wolopts = 0;
1831 
1832  if (!(adapter->flags & FLAG_HAS_WOL) ||
1833  !device_can_wakeup(&adapter->pdev->dev))
1834  return;
1835 
1836  wol->supported = WAKE_UCAST | WAKE_MCAST |
1837  WAKE_BCAST | WAKE_MAGIC | WAKE_PHY;
1838 
1839  /* apply any specific unsupported masks here */
1840  if (adapter->flags & FLAG_NO_WAKE_UCAST) {
1841  wol->supported &= ~WAKE_UCAST;
1842 
1843  if (adapter->wol & E1000_WUFC_EX)
1844  e_err("Interface does not support directed (unicast) frame wake-up packets\n");
1845  }
1846 
1847  if (adapter->wol & E1000_WUFC_EX)
1848  wol->wolopts |= WAKE_UCAST;
1849  if (adapter->wol & E1000_WUFC_MC)
1850  wol->wolopts |= WAKE_MCAST;
1851  if (adapter->wol & E1000_WUFC_BC)
1852  wol->wolopts |= WAKE_BCAST;
1853  if (adapter->wol & E1000_WUFC_MAG)
1854  wol->wolopts |= WAKE_MAGIC;
1855  if (adapter->wol & E1000_WUFC_LNKC)
1856  wol->wolopts |= WAKE_PHY;
1857 }
1858 
1859 static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1860 {
1861  struct e1000_adapter *adapter = netdev_priv(netdev);
1862 
1863  if (!(adapter->flags & FLAG_HAS_WOL) ||
1864  !device_can_wakeup(&adapter->pdev->dev) ||
1865  (wol->wolopts & ~(WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |
1866  WAKE_MAGIC | WAKE_PHY)))
1867  return -EOPNOTSUPP;
1868 
1869  /* these settings will always override what we currently have */
1870  adapter->wol = 0;
1871 
1872  if (wol->wolopts & WAKE_UCAST)
1873  adapter->wol |= E1000_WUFC_EX;
1874  if (wol->wolopts & WAKE_MCAST)
1875  adapter->wol |= E1000_WUFC_MC;
1876  if (wol->wolopts & WAKE_BCAST)
1877  adapter->wol |= E1000_WUFC_BC;
1878  if (wol->wolopts & WAKE_MAGIC)
1879  adapter->wol |= E1000_WUFC_MAG;
1880  if (wol->wolopts & WAKE_PHY)
1881  adapter->wol |= E1000_WUFC_LNKC;
1882 
1883  device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1884 
1885  return 0;
1886 }
1887 
1888 static int e1000_set_phys_id(struct net_device *netdev,
1889  enum ethtool_phys_id_state state)
1890 {
1891  struct e1000_adapter *adapter = netdev_priv(netdev);
1892  struct e1000_hw *hw = &adapter->hw;
1893 
1894  switch (state) {
1895  case ETHTOOL_ID_ACTIVE:
1896  if (!hw->mac.ops.blink_led)
1897  return 2; /* cycle on/off twice per second */
1898 
1899  hw->mac.ops.blink_led(hw);
1900  break;
1901 
1902  case ETHTOOL_ID_INACTIVE:
1903  if (hw->phy.type == e1000_phy_ife)
1904  e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);
1905  hw->mac.ops.led_off(hw);
1906  hw->mac.ops.cleanup_led(hw);
1907  break;
1908 
1909  case ETHTOOL_ID_ON:
1910  hw->mac.ops.led_on(hw);
1911  break;
1912 
1913  case ETHTOOL_ID_OFF:
1914  hw->mac.ops.led_off(hw);
1915  break;
1916  }
1917  return 0;
1918 }
1919 
1920 static int e1000_get_coalesce(struct net_device *netdev,
1921  struct ethtool_coalesce *ec)
1922 {
1923  struct e1000_adapter *adapter = netdev_priv(netdev);
1924 
1925  if (adapter->itr_setting <= 4)
1926  ec->rx_coalesce_usecs = adapter->itr_setting;
1927  else
1928  ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;
1929 
1930  return 0;
1931 }
1932 
1933 static int e1000_set_coalesce(struct net_device *netdev,
1934  struct ethtool_coalesce *ec)
1935 {
1936  struct e1000_adapter *adapter = netdev_priv(netdev);
1937 
1938  if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
1939  ((ec->rx_coalesce_usecs > 4) &&
1940  (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
1941  (ec->rx_coalesce_usecs == 2))
1942  return -EINVAL;
1943 
1944  if (ec->rx_coalesce_usecs == 4) {
1945  adapter->itr_setting = 4;
1946  adapter->itr = adapter->itr_setting;
1947  } else if (ec->rx_coalesce_usecs <= 3) {
1948  adapter->itr = 20000;
1949  adapter->itr_setting = ec->rx_coalesce_usecs;
1950  } else {
1951  adapter->itr = (1000000 / ec->rx_coalesce_usecs);
1952  adapter->itr_setting = adapter->itr & ~3;
1953  }
1954 
1955  if (adapter->itr_setting != 0)
1956  e1000e_write_itr(adapter, adapter->itr);
1957  else
1958  e1000e_write_itr(adapter, 0);
1959 
1960  return 0;
1961 }
1962 
1963 static int e1000_nway_reset(struct net_device *netdev)
1964 {
1965  struct e1000_adapter *adapter = netdev_priv(netdev);
1966 
1967  if (!netif_running(netdev))
1968  return -EAGAIN;
1969 
1970  if (!adapter->hw.mac.autoneg)
1971  return -EINVAL;
1972 
1973  e1000e_reinit_locked(adapter);
1974 
1975  return 0;
1976 }
1977 
1978 static void e1000_get_ethtool_stats(struct net_device *netdev,
1979  struct ethtool_stats *stats,
1980  u64 *data)
1981 {
1982  struct e1000_adapter *adapter = netdev_priv(netdev);
1983  struct rtnl_link_stats64 net_stats;
1984  int i;
1985  char *p = NULL;
1986 
1987  e1000e_get_stats64(netdev, &net_stats);
1988  for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
1989  switch (e1000_gstrings_stats[i].type) {
1990  case NETDEV_STATS:
1991  p = (char *) &net_stats +
1992  e1000_gstrings_stats[i].stat_offset;
1993  break;
1994  case E1000_STATS:
1995  p = (char *) adapter +
1996  e1000_gstrings_stats[i].stat_offset;
1997  break;
1998  default:
1999  data[i] = 0;
2000  continue;
2001  }
2002 
2003  data[i] = (e1000_gstrings_stats[i].sizeof_stat ==
2004  sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
2005  }
2006 }
2007 
2008 static void e1000_get_strings(struct net_device *netdev, u32 stringset,
2009  u8 *data)
2010 {
2011  u8 *p = data;
2012  int i;
2013 
2014  switch (stringset) {
2015  case ETH_SS_TEST:
2016  memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
2017  break;
2018  case ETH_SS_STATS:
2019  for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
2020  memcpy(p, e1000_gstrings_stats[i].stat_string,
2021  ETH_GSTRING_LEN);
2022  p += ETH_GSTRING_LEN;
2023  }
2024  break;
2025  }
2026 }
2027 
2028 static int e1000_get_rxnfc(struct net_device *netdev,
2029  struct ethtool_rxnfc *info, u32 *rule_locs)
2030 {
2031  info->data = 0;
2032 
2033  switch (info->cmd) {
2034  case ETHTOOL_GRXFH: {
2035  struct e1000_adapter *adapter = netdev_priv(netdev);
2036  struct e1000_hw *hw = &adapter->hw;
2037  u32 mrqc = er32(MRQC);
2038 
2039  if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK))
2040  return 0;
2041 
2042  switch (info->flow_type) {
2043  case TCP_V4_FLOW:
2044  if (mrqc & E1000_MRQC_RSS_FIELD_IPV4_TCP)
2045  info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2046  /* fall through */
2047  case UDP_V4_FLOW:
2048  case SCTP_V4_FLOW:
2049  case AH_ESP_V4_FLOW:
2050  case IPV4_FLOW:
2051  if (mrqc & E1000_MRQC_RSS_FIELD_IPV4)
2052  info->data |= RXH_IP_SRC | RXH_IP_DST;
2053  break;
2054  case TCP_V6_FLOW:
2055  if (mrqc & E1000_MRQC_RSS_FIELD_IPV6_TCP)
2056  info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2057  /* fall through */
2058  case UDP_V6_FLOW:
2059  case SCTP_V6_FLOW:
2060  case AH_ESP_V6_FLOW:
2061  case IPV6_FLOW:
2062  if (mrqc & E1000_MRQC_RSS_FIELD_IPV6)
2063  info->data |= RXH_IP_SRC | RXH_IP_DST;
2064  break;
2065  default:
2066  break;
2067  }
2068  return 0;
2069  }
2070  default:
2071  return -EOPNOTSUPP;
2072  }
2073 }
2074 
2075 static const struct ethtool_ops e1000_ethtool_ops = {
2076  .get_settings = e1000_get_settings,
2077  .set_settings = e1000_set_settings,
2078  .get_drvinfo = e1000_get_drvinfo,
2079  .get_regs_len = e1000_get_regs_len,
2080  .get_regs = e1000_get_regs,
2081  .get_wol = e1000_get_wol,
2082  .set_wol = e1000_set_wol,
2083  .get_msglevel = e1000_get_msglevel,
2084  .set_msglevel = e1000_set_msglevel,
2085  .nway_reset = e1000_nway_reset,
2086  .get_link = ethtool_op_get_link,
2087  .get_eeprom_len = e1000_get_eeprom_len,
2088  .get_eeprom = e1000_get_eeprom,
2089  .set_eeprom = e1000_set_eeprom,
2090  .get_ringparam = e1000_get_ringparam,
2091  .set_ringparam = e1000_set_ringparam,
2092  .get_pauseparam = e1000_get_pauseparam,
2093  .set_pauseparam = e1000_set_pauseparam,
2094  .self_test = e1000_diag_test,
2095  .get_strings = e1000_get_strings,
2096  .set_phys_id = e1000_set_phys_id,
2097  .get_ethtool_stats = e1000_get_ethtool_stats,
2098  .get_sset_count = e1000e_get_sset_count,
2099  .get_coalesce = e1000_get_coalesce,
2100  .set_coalesce = e1000_set_coalesce,
2101  .get_rxnfc = e1000_get_rxnfc,
2102  .get_ts_info = ethtool_op_get_ts_info,
2103 };
2104 
2105 void e1000e_set_ethtool_ops(struct net_device *netdev)
2106 {
2107  SET_ETHTOOL_OPS(netdev, &e1000_ethtool_ops);
2108 }
Generated on Thu Jan 10 2013 14:02:12 for Linux Kernel by   doxygen 1.8.2