Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
qlcnic_ethtool.c
Go to the documentation of this file.
1 /*
2  * QLogic qlcnic NIC Driver
3  * Copyright (c) 2009-2010 QLogic Corporation
4  *
5  * See LICENSE.qlcnic for copyright and licensing details.
6  */
7 
8 #include <linux/types.h>
9 #include <linux/delay.h>
10 #include <linux/pci.h>
11 #include <linux/io.h>
12 #include <linux/netdevice.h>
13 #include <linux/ethtool.h>
14 
15 #include "qlcnic.h"
16 
17 struct qlcnic_stats {
18  char stat_string[ETH_GSTRING_LEN];
19  int sizeof_stat;
20  int stat_offset;
21 };
22 
23 #define QLC_SIZEOF(m) FIELD_SIZEOF(struct qlcnic_adapter, m)
24 #define QLC_OFF(m) offsetof(struct qlcnic_adapter, m)
25 
26 static const struct qlcnic_stats qlcnic_gstrings_stats[] = {
27  {"xmit_called",
28  QLC_SIZEOF(stats.xmitcalled), QLC_OFF(stats.xmitcalled)},
29  {"xmit_finished",
30  QLC_SIZEOF(stats.xmitfinished), QLC_OFF(stats.xmitfinished)},
31  {"rx_dropped",
32  QLC_SIZEOF(stats.rxdropped), QLC_OFF(stats.rxdropped)},
33  {"tx_dropped",
34  QLC_SIZEOF(stats.txdropped), QLC_OFF(stats.txdropped)},
35  {"csummed",
36  QLC_SIZEOF(stats.csummed), QLC_OFF(stats.csummed)},
37  {"rx_pkts",
38  QLC_SIZEOF(stats.rx_pkts), QLC_OFF(stats.rx_pkts)},
39  {"lro_pkts",
40  QLC_SIZEOF(stats.lro_pkts), QLC_OFF(stats.lro_pkts)},
41  {"rx_bytes",
42  QLC_SIZEOF(stats.rxbytes), QLC_OFF(stats.rxbytes)},
43  {"tx_bytes",
44  QLC_SIZEOF(stats.txbytes), QLC_OFF(stats.txbytes)},
45  {"lrobytes",
46  QLC_SIZEOF(stats.lrobytes), QLC_OFF(stats.lrobytes)},
47  {"lso_frames",
48  QLC_SIZEOF(stats.lso_frames), QLC_OFF(stats.lso_frames)},
49  {"xmit_on",
50  QLC_SIZEOF(stats.xmit_on), QLC_OFF(stats.xmit_on)},
51  {"xmit_off",
52  QLC_SIZEOF(stats.xmit_off), QLC_OFF(stats.xmit_off)},
53  {"skb_alloc_failure", QLC_SIZEOF(stats.skb_alloc_failure),
54  QLC_OFF(stats.skb_alloc_failure)},
55  {"null rxbuf",
56  QLC_SIZEOF(stats.null_rxbuf), QLC_OFF(stats.null_rxbuf)},
57  {"rx dma map error", QLC_SIZEOF(stats.rx_dma_map_error),
58  QLC_OFF(stats.rx_dma_map_error)},
59  {"tx dma map error", QLC_SIZEOF(stats.tx_dma_map_error),
60  QLC_OFF(stats.tx_dma_map_error)},
61 
62 };
63 
64 static const char qlcnic_device_gstrings_stats[][ETH_GSTRING_LEN] = {
65  "rx unicast frames",
66  "rx multicast frames",
67  "rx broadcast frames",
68  "rx dropped frames",
69  "rx errors",
70  "rx local frames",
71  "rx numbytes",
72  "tx unicast frames",
73  "tx multicast frames",
74  "tx broadcast frames",
75  "tx dropped frames",
76  "tx errors",
77  "tx local frames",
78  "tx numbytes",
79 };
80 
81 static const char qlcnic_mac_stats_strings [][ETH_GSTRING_LEN] = {
82  "mac_tx_frames",
83  "mac_tx_bytes",
84  "mac_tx_mcast_pkts",
85  "mac_tx_bcast_pkts",
86  "mac_tx_pause_cnt",
87  "mac_tx_ctrl_pkt",
88  "mac_tx_lt_64b_pkts",
89  "mac_tx_lt_127b_pkts",
90  "mac_tx_lt_255b_pkts",
91  "mac_tx_lt_511b_pkts",
92  "mac_tx_lt_1023b_pkts",
93  "mac_tx_lt_1518b_pkts",
94  "mac_tx_gt_1518b_pkts",
95  "mac_rx_frames",
96  "mac_rx_bytes",
97  "mac_rx_mcast_pkts",
98  "mac_rx_bcast_pkts",
99  "mac_rx_pause_cnt",
100  "mac_rx_ctrl_pkt",
101  "mac_rx_lt_64b_pkts",
102  "mac_rx_lt_127b_pkts",
103  "mac_rx_lt_255b_pkts",
104  "mac_rx_lt_511b_pkts",
105  "mac_rx_lt_1023b_pkts",
106  "mac_rx_lt_1518b_pkts",
107  "mac_rx_gt_1518b_pkts",
108  "mac_rx_length_error",
109  "mac_rx_length_small",
110  "mac_rx_length_large",
111  "mac_rx_jabber",
112  "mac_rx_dropped",
113  "mac_rx_crc_error",
114  "mac_align_error",
115 };
116 
117 #define QLCNIC_STATS_LEN ARRAY_SIZE(qlcnic_gstrings_stats)
118 #define QLCNIC_MAC_STATS_LEN ARRAY_SIZE(qlcnic_mac_stats_strings)
119 #define QLCNIC_DEVICE_STATS_LEN ARRAY_SIZE(qlcnic_device_gstrings_stats)
120 #define QLCNIC_TOTAL_STATS_LEN QLCNIC_STATS_LEN + QLCNIC_MAC_STATS_LEN
121 
122 static const char qlcnic_gstrings_test[][ETH_GSTRING_LEN] = {
123  "Register_Test_on_offline",
124  "Link_Test_on_offline",
125  "Interrupt_Test_offline",
126  "Internal_Loopback_offline",
127  "External_Loopback_offline"
128 };
129 
130 #define QLCNIC_TEST_LEN ARRAY_SIZE(qlcnic_gstrings_test)
131 
132 #define QLCNIC_RING_REGS_COUNT 20
133 #define QLCNIC_RING_REGS_LEN (QLCNIC_RING_REGS_COUNT * sizeof(u32))
134 #define QLCNIC_MAX_EEPROM_LEN 1024
135 
136 static const u32 diag_registers[] = {
137  CRB_CMDPEG_STATE,
138  CRB_RCVPEG_STATE,
139  CRB_XG_STATE_P3P,
140  CRB_FW_CAPABILITIES_1,
141  ISR_INT_STATE_REG,
142  QLCNIC_CRB_DRV_ACTIVE,
143  QLCNIC_CRB_DEV_STATE,
144  QLCNIC_CRB_DRV_STATE,
145  QLCNIC_CRB_DRV_SCRATCH,
146  QLCNIC_CRB_DEV_PARTITION_INFO,
147  QLCNIC_CRB_DRV_IDC_VER,
148  QLCNIC_PEG_ALIVE_COUNTER,
149  QLCNIC_PEG_HALT_STATUS1,
150  QLCNIC_PEG_HALT_STATUS2,
151  QLCNIC_CRB_PEG_NET_0+0x3c,
152  QLCNIC_CRB_PEG_NET_1+0x3c,
153  QLCNIC_CRB_PEG_NET_2+0x3c,
154  QLCNIC_CRB_PEG_NET_4+0x3c,
155  -1
156 };
157 
158 #define QLCNIC_MGMT_API_VERSION 2
159 #define QLCNIC_DEV_INFO_SIZE 1
160 #define QLCNIC_ETHTOOL_REGS_VER 2
161 static int qlcnic_get_regs_len(struct net_device *dev)
162 {
163  return sizeof(diag_registers) + QLCNIC_RING_REGS_LEN +
164  QLCNIC_DEV_INFO_SIZE + 1;
165 }
166 
167 static int qlcnic_get_eeprom_len(struct net_device *dev)
168 {
169  return QLCNIC_FLASH_TOTAL_SIZE;
170 }
171 
172 static void
173 qlcnic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
174 {
175  struct qlcnic_adapter *adapter = netdev_priv(dev);
176  u32 fw_major, fw_minor, fw_build;
177 
178  fw_major = QLCRD32(adapter, QLCNIC_FW_VERSION_MAJOR);
179  fw_minor = QLCRD32(adapter, QLCNIC_FW_VERSION_MINOR);
180  fw_build = QLCRD32(adapter, QLCNIC_FW_VERSION_SUB);
181  snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
182  "%d.%d.%d", fw_major, fw_minor, fw_build);
183 
184  strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
185  sizeof(drvinfo->bus_info));
186  strlcpy(drvinfo->driver, qlcnic_driver_name, sizeof(drvinfo->driver));
187  strlcpy(drvinfo->version, QLCNIC_LINUX_VERSIONID,
188  sizeof(drvinfo->version));
189 }
190 
191 static int
192 qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
193 {
194  struct qlcnic_adapter *adapter = netdev_priv(dev);
195  int check_sfp_module = 0;
196 
197  /* read which mode */
198  if (adapter->ahw->port_type == QLCNIC_GBE) {
199  ecmd->supported = (SUPPORTED_10baseT_Half |
200  SUPPORTED_10baseT_Full |
201  SUPPORTED_100baseT_Half |
202  SUPPORTED_100baseT_Full |
203  SUPPORTED_1000baseT_Half |
204  SUPPORTED_1000baseT_Full);
205 
206  ecmd->advertising = (ADVERTISED_100baseT_Half |
207  ADVERTISED_100baseT_Full |
208  ADVERTISED_1000baseT_Half |
209  ADVERTISED_1000baseT_Full);
210 
211  ethtool_cmd_speed_set(ecmd, adapter->link_speed);
212  ecmd->duplex = adapter->link_duplex;
213  ecmd->autoneg = adapter->link_autoneg;
214 
215  } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
216  u32 val;
217 
218  val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR);
219  if (val == QLCNIC_PORT_MODE_802_3_AP) {
220  ecmd->supported = SUPPORTED_1000baseT_Full;
221  ecmd->advertising = ADVERTISED_1000baseT_Full;
222  } else {
223  ecmd->supported = SUPPORTED_10000baseT_Full;
224  ecmd->advertising = ADVERTISED_10000baseT_Full;
225  }
226 
227  if (netif_running(dev) && adapter->has_link_events) {
228  ethtool_cmd_speed_set(ecmd, adapter->link_speed);
229  ecmd->autoneg = adapter->link_autoneg;
230  ecmd->duplex = adapter->link_duplex;
231  goto skip;
232  }
233 
234  ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN);
235  ecmd->duplex = DUPLEX_UNKNOWN;
236  ecmd->autoneg = AUTONEG_DISABLE;
237  } else
238  return -EIO;
239 
240 skip:
241  ecmd->phy_address = adapter->physical_port;
242  ecmd->transceiver = XCVR_EXTERNAL;
243 
244  switch (adapter->ahw->board_type) {
245  case QLCNIC_BRDTYPE_P3P_REF_QG:
246  case QLCNIC_BRDTYPE_P3P_4_GB:
247  case QLCNIC_BRDTYPE_P3P_4_GB_MM:
248 
249  ecmd->supported |= SUPPORTED_Autoneg;
250  ecmd->advertising |= ADVERTISED_Autoneg;
251  case QLCNIC_BRDTYPE_P3P_10G_CX4:
252  case QLCNIC_BRDTYPE_P3P_10G_CX4_LP:
253  case QLCNIC_BRDTYPE_P3P_10000_BASE_T:
254  ecmd->supported |= SUPPORTED_TP;
255  ecmd->advertising |= ADVERTISED_TP;
256  ecmd->port = PORT_TP;
257  ecmd->autoneg = adapter->link_autoneg;
258  break;
259  case QLCNIC_BRDTYPE_P3P_IMEZ:
260  case QLCNIC_BRDTYPE_P3P_XG_LOM:
261  case QLCNIC_BRDTYPE_P3P_HMEZ:
262  ecmd->supported |= SUPPORTED_MII;
263  ecmd->advertising |= ADVERTISED_MII;
264  ecmd->port = PORT_MII;
265  ecmd->autoneg = AUTONEG_DISABLE;
266  break;
267  case QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS:
268  case QLCNIC_BRDTYPE_P3P_10G_SFP_CT:
269  case QLCNIC_BRDTYPE_P3P_10G_SFP_QT:
270  ecmd->advertising |= ADVERTISED_TP;
271  ecmd->supported |= SUPPORTED_TP;
272  check_sfp_module = netif_running(dev) &&
273  adapter->has_link_events;
274  case QLCNIC_BRDTYPE_P3P_10G_XFP:
275  ecmd->supported |= SUPPORTED_FIBRE;
276  ecmd->advertising |= ADVERTISED_FIBRE;
277  ecmd->port = PORT_FIBRE;
278  ecmd->autoneg = AUTONEG_DISABLE;
279  break;
280  case QLCNIC_BRDTYPE_P3P_10G_TP:
281  if (adapter->ahw->port_type == QLCNIC_XGBE) {
282  ecmd->autoneg = AUTONEG_DISABLE;
283  ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
284  ecmd->advertising |=
285  (ADVERTISED_FIBRE | ADVERTISED_TP);
286  ecmd->port = PORT_FIBRE;
287  check_sfp_module = netif_running(dev) &&
288  adapter->has_link_events;
289  } else {
290  ecmd->autoneg = AUTONEG_ENABLE;
291  ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg);
292  ecmd->advertising |=
293  (ADVERTISED_TP | ADVERTISED_Autoneg);
294  ecmd->port = PORT_TP;
295  }
296  break;
297  default:
298  dev_err(&adapter->pdev->dev, "Unsupported board model %d\n",
299  adapter->ahw->board_type);
300  return -EIO;
301  }
302 
303  if (check_sfp_module) {
304  switch (adapter->module_type) {
305  case LINKEVENT_MODULE_OPTICAL_UNKNOWN:
306  case LINKEVENT_MODULE_OPTICAL_SRLR:
307  case LINKEVENT_MODULE_OPTICAL_LRM:
308  case LINKEVENT_MODULE_OPTICAL_SFP_1G:
309  ecmd->port = PORT_FIBRE;
310  break;
311  case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE:
312  case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN:
313  case LINKEVENT_MODULE_TWINAX:
314  ecmd->port = PORT_TP;
315  break;
316  default:
317  ecmd->port = PORT_OTHER;
318  }
319  }
320 
321  return 0;
322 }
323 
324 static int
325 qlcnic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
326 {
327  u32 config = 0;
328  u32 ret = 0;
329  struct qlcnic_adapter *adapter = netdev_priv(dev);
330 
331  if (adapter->ahw->port_type != QLCNIC_GBE)
332  return -EOPNOTSUPP;
333 
334  /* read which mode */
335  if (ecmd->duplex)
336  config |= 0x1;
337 
338  if (ecmd->autoneg)
339  config |= 0x2;
340 
341  switch (ethtool_cmd_speed(ecmd)) {
342  case SPEED_10:
343  config |= (0 << 8);
344  break;
345  case SPEED_100:
346  config |= (1 << 8);
347  break;
348  case SPEED_1000:
349  config |= (10 << 8);
350  break;
351  default:
352  return -EIO;
353  }
354 
355  ret = qlcnic_fw_cmd_set_port(adapter, config);
356 
357  if (ret == QLCNIC_RCODE_NOT_SUPPORTED)
358  return -EOPNOTSUPP;
359  else if (ret)
360  return -EIO;
361 
362  adapter->link_speed = ethtool_cmd_speed(ecmd);
363  adapter->link_duplex = ecmd->duplex;
364  adapter->link_autoneg = ecmd->autoneg;
365 
366  if (!netif_running(dev))
367  return 0;
368 
369  dev->netdev_ops->ndo_stop(dev);
370  return dev->netdev_ops->ndo_open(dev);
371 }
372 
373 static void
374 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
375 {
376  struct qlcnic_adapter *adapter = netdev_priv(dev);
377  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
378  struct qlcnic_host_sds_ring *sds_ring;
379  u32 *regs_buff = p;
380  int ring, i = 0, j = 0;
381 
382  memset(p, 0, qlcnic_get_regs_len(dev));
383  regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) |
384  (adapter->ahw->revision_id << 16) | (adapter->pdev)->device;
385 
386  regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff));
387  regs_buff[1] = QLCNIC_MGMT_API_VERSION;
388 
389  for (i = QLCNIC_DEV_INFO_SIZE + 1; diag_registers[j] != -1; j++, i++)
390  regs_buff[i] = QLCRD32(adapter, diag_registers[j]);
391 
392  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
393  return;
394 
395  regs_buff[i++] = 0xFFEFCDAB; /* Marker btw regs and ring count*/
396 
397  regs_buff[i++] = 1; /* No. of tx ring */
398  regs_buff[i++] = le32_to_cpu(*(adapter->tx_ring->hw_consumer));
399  regs_buff[i++] = readl(adapter->tx_ring->crb_cmd_producer);
400 
401  regs_buff[i++] = 2; /* No. of rx ring */
402  regs_buff[i++] = readl(recv_ctx->rds_rings[0].crb_rcv_producer);
403  regs_buff[i++] = readl(recv_ctx->rds_rings[1].crb_rcv_producer);
404 
405  regs_buff[i++] = adapter->max_sds_rings;
406 
407  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
408  sds_ring = &(recv_ctx->sds_rings[ring]);
409  regs_buff[i++] = readl(sds_ring->crb_sts_consumer);
410  }
411 }
412 
413 static u32 qlcnic_test_link(struct net_device *dev)
414 {
415  struct qlcnic_adapter *adapter = netdev_priv(dev);
416  u32 val;
417 
418  val = QLCRD32(adapter, CRB_XG_STATE_P3P);
419  val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val);
420  return (val == XG_LINK_UP_P3P) ? 0 : 1;
421 }
422 
423 static int
424 qlcnic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
425  u8 *bytes)
426 {
427  struct qlcnic_adapter *adapter = netdev_priv(dev);
428  int offset;
429  int ret;
430 
431  if (eeprom->len == 0)
432  return -EINVAL;
433 
434  eeprom->magic = (adapter->pdev)->vendor |
435  ((adapter->pdev)->device << 16);
436  offset = eeprom->offset;
437 
438  ret = qlcnic_rom_fast_read_words(adapter, offset, bytes,
439  eeprom->len);
440  if (ret < 0)
441  return ret;
442 
443  return 0;
444 }
445 
446 static void
447 qlcnic_get_ringparam(struct net_device *dev,
448  struct ethtool_ringparam *ring)
449 {
450  struct qlcnic_adapter *adapter = netdev_priv(dev);
451 
452  ring->rx_pending = adapter->num_rxd;
453  ring->rx_jumbo_pending = adapter->num_jumbo_rxd;
454  ring->tx_pending = adapter->num_txd;
455 
456  ring->rx_max_pending = adapter->max_rxd;
457  ring->rx_jumbo_max_pending = adapter->max_jumbo_rxd;
458  ring->tx_max_pending = MAX_CMD_DESCRIPTORS;
459 }
460 
461 static u32
462 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name)
463 {
464  u32 num_desc;
465  num_desc = max(val, min);
466  num_desc = min(num_desc, max);
467  num_desc = roundup_pow_of_two(num_desc);
468 
469  if (val != num_desc) {
470  printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n",
471  qlcnic_driver_name, r_name, num_desc, val);
472  }
473 
474  return num_desc;
475 }
476 
477 static int
478 qlcnic_set_ringparam(struct net_device *dev,
479  struct ethtool_ringparam *ring)
480 {
481  struct qlcnic_adapter *adapter = netdev_priv(dev);
482  u16 num_rxd, num_jumbo_rxd, num_txd;
483 
484  if (ring->rx_mini_pending)
485  return -EOPNOTSUPP;
486 
487  num_rxd = qlcnic_validate_ringparam(ring->rx_pending,
488  MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx");
489 
490  num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending,
491  MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd,
492  "rx jumbo");
493 
494  num_txd = qlcnic_validate_ringparam(ring->tx_pending,
495  MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx");
496 
497  if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd &&
498  num_jumbo_rxd == adapter->num_jumbo_rxd)
499  return 0;
500 
501  adapter->num_rxd = num_rxd;
502  adapter->num_jumbo_rxd = num_jumbo_rxd;
503  adapter->num_txd = num_txd;
504 
505  return qlcnic_reset_context(adapter);
506 }
507 
508 static void qlcnic_get_channels(struct net_device *dev,
509  struct ethtool_channels *channel)
510 {
511  struct qlcnic_adapter *adapter = netdev_priv(dev);
512 
513  channel->max_rx = rounddown_pow_of_two(min_t(int,
514  adapter->max_rx_ques, num_online_cpus()));
515  channel->max_tx = adapter->max_tx_ques;
516 
517  channel->rx_count = adapter->max_sds_rings;
518  channel->tx_count = adapter->max_tx_ques;
519 }
520 
521 static int qlcnic_set_channels(struct net_device *dev,
522  struct ethtool_channels *channel)
523 {
524  struct qlcnic_adapter *adapter = netdev_priv(dev);
525  int err;
526 
527  if (channel->other_count || channel->combined_count ||
528  channel->tx_count != channel->max_tx)
529  return -EINVAL;
530 
531  err = qlcnic_validate_max_rss(dev, channel->max_rx, channel->rx_count);
532  if (err)
533  return err;
534 
535  err = qlcnic_set_max_rss(adapter, channel->rx_count);
536  netdev_info(dev, "allocated 0x%x sds rings\n",
537  adapter->max_sds_rings);
538  return err;
539 }
540 
541 static void
542 qlcnic_get_pauseparam(struct net_device *netdev,
543  struct ethtool_pauseparam *pause)
544 {
545  struct qlcnic_adapter *adapter = netdev_priv(netdev);
546  int port = adapter->physical_port;
547  __u32 val;
548 
549  if (adapter->ahw->port_type == QLCNIC_GBE) {
550  if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
551  return;
552  /* get flow control settings */
553  val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
554  pause->rx_pause = qlcnic_gb_get_rx_flowctl(val);
555  val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
556  switch (port) {
557  case 0:
558  pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val));
559  break;
560  case 1:
561  pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val));
562  break;
563  case 2:
564  pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val));
565  break;
566  case 3:
567  default:
568  pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val));
569  break;
570  }
571  } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
572  if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
573  return;
574  pause->rx_pause = 1;
575  val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
576  if (port == 0)
577  pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val));
578  else
579  pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val));
580  } else {
581  dev_err(&netdev->dev, "Unknown board type: %x\n",
582  adapter->ahw->port_type);
583  }
584 }
585 
586 static int
587 qlcnic_set_pauseparam(struct net_device *netdev,
588  struct ethtool_pauseparam *pause)
589 {
590  struct qlcnic_adapter *adapter = netdev_priv(netdev);
591  int port = adapter->physical_port;
592  __u32 val;
593 
594  /* read mode */
595  if (adapter->ahw->port_type == QLCNIC_GBE) {
596  if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
597  return -EIO;
598  /* set flow control */
599  val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
600 
601  if (pause->rx_pause)
602  qlcnic_gb_rx_flowctl(val);
603  else
604  qlcnic_gb_unset_rx_flowctl(val);
605 
606  QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port),
607  val);
608  /* set autoneg */
609  val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
610  switch (port) {
611  case 0:
612  if (pause->tx_pause)
613  qlcnic_gb_unset_gb0_mask(val);
614  else
615  qlcnic_gb_set_gb0_mask(val);
616  break;
617  case 1:
618  if (pause->tx_pause)
619  qlcnic_gb_unset_gb1_mask(val);
620  else
621  qlcnic_gb_set_gb1_mask(val);
622  break;
623  case 2:
624  if (pause->tx_pause)
625  qlcnic_gb_unset_gb2_mask(val);
626  else
627  qlcnic_gb_set_gb2_mask(val);
628  break;
629  case 3:
630  default:
631  if (pause->tx_pause)
632  qlcnic_gb_unset_gb3_mask(val);
633  else
634  qlcnic_gb_set_gb3_mask(val);
635  break;
636  }
637  QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val);
638  } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
639  if (!pause->rx_pause || pause->autoneg)
640  return -EOPNOTSUPP;
641 
642  if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
643  return -EIO;
644 
645  val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
646  if (port == 0) {
647  if (pause->tx_pause)
648  qlcnic_xg_unset_xg0_mask(val);
649  else
650  qlcnic_xg_set_xg0_mask(val);
651  } else {
652  if (pause->tx_pause)
653  qlcnic_xg_unset_xg1_mask(val);
654  else
655  qlcnic_xg_set_xg1_mask(val);
656  }
657  QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val);
658  } else {
659  dev_err(&netdev->dev, "Unknown board type: %x\n",
660  adapter->ahw->port_type);
661  }
662  return 0;
663 }
664 
665 static int qlcnic_reg_test(struct net_device *dev)
666 {
667  struct qlcnic_adapter *adapter = netdev_priv(dev);
668  u32 data_read;
669 
670  data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0));
671  if ((data_read & 0xffff) != adapter->pdev->vendor)
672  return 1;
673 
674  return 0;
675 }
676 
677 static int qlcnic_get_sset_count(struct net_device *dev, int sset)
678 {
679  struct qlcnic_adapter *adapter = netdev_priv(dev);
680  switch (sset) {
681  case ETH_SS_TEST:
682  return QLCNIC_TEST_LEN;
683  case ETH_SS_STATS:
684  if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
685  return QLCNIC_TOTAL_STATS_LEN + QLCNIC_DEVICE_STATS_LEN;
686  return QLCNIC_TOTAL_STATS_LEN;
687  default:
688  return -EOPNOTSUPP;
689  }
690 }
691 
692 static int qlcnic_irq_test(struct net_device *netdev)
693 {
694  struct qlcnic_adapter *adapter = netdev_priv(netdev);
695  int max_sds_rings = adapter->max_sds_rings;
696  int ret;
697  struct qlcnic_cmd_args cmd;
698 
699  if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
700  return -EIO;
701 
702  ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST);
703  if (ret)
704  goto clear_it;
705 
706  adapter->diag_cnt = 0;
707  memset(&cmd, 0, sizeof(cmd));
708  cmd.req.cmd = QLCNIC_CDRP_CMD_INTRPT_TEST;
709  cmd.req.arg1 = adapter->ahw->pci_func;
710  qlcnic_issue_cmd(adapter, &cmd);
711  ret = cmd.rsp.cmd;
712 
713  if (ret)
714  goto done;
715 
716  msleep(10);
717 
718  ret = !adapter->diag_cnt;
719 
720 done:
721  qlcnic_diag_free_res(netdev, max_sds_rings);
722 
723 clear_it:
724  adapter->max_sds_rings = max_sds_rings;
725  clear_bit(__QLCNIC_RESETTING, &adapter->state);
726  return ret;
727 }
728 
729 #define QLCNIC_ILB_PKT_SIZE 64
730 #define QLCNIC_NUM_ILB_PKT 16
731 #define QLCNIC_ILB_MAX_RCV_LOOP 10
732 
733 static void qlcnic_create_loopback_buff(unsigned char *data, u8 mac[])
734 {
735  unsigned char random_data[] = {0xa8, 0x06, 0x45, 0x00};
736 
737  memset(data, 0x4e, QLCNIC_ILB_PKT_SIZE);
738 
739  memcpy(data, mac, ETH_ALEN);
740  memcpy(data + ETH_ALEN, mac, ETH_ALEN);
741 
742  memcpy(data + 2 * ETH_ALEN, random_data, sizeof(random_data));
743 }
744 
745 int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[])
746 {
747  unsigned char buff[QLCNIC_ILB_PKT_SIZE];
748  qlcnic_create_loopback_buff(buff, mac);
749  return memcmp(data, buff, QLCNIC_ILB_PKT_SIZE);
750 }
751 
752 static int qlcnic_do_lb_test(struct qlcnic_adapter *adapter, u8 mode)
753 {
754  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
755  struct qlcnic_host_sds_ring *sds_ring = &recv_ctx->sds_rings[0];
756  struct sk_buff *skb;
757  int i, loop, cnt = 0;
758 
759  for (i = 0; i < QLCNIC_NUM_ILB_PKT; i++) {
760  skb = netdev_alloc_skb(adapter->netdev, QLCNIC_ILB_PKT_SIZE);
761  qlcnic_create_loopback_buff(skb->data, adapter->mac_addr);
762  skb_put(skb, QLCNIC_ILB_PKT_SIZE);
763 
764  adapter->diag_cnt = 0;
765  qlcnic_xmit_frame(skb, adapter->netdev);
766 
767  loop = 0;
768  do {
769  msleep(1);
770  qlcnic_process_rcv_ring_diag(sds_ring);
771  if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP)
772  break;
773  } while (!adapter->diag_cnt);
774 
775  dev_kfree_skb_any(skb);
776 
777  if (!adapter->diag_cnt)
778  QLCDB(adapter, DRV,
779  "LB Test: packet #%d was not received\n", i + 1);
780  else
781  cnt++;
782  }
783  if (cnt != i) {
784  dev_warn(&adapter->pdev->dev, "LB Test failed\n");
785  if (mode != QLCNIC_ILB_MODE) {
786  dev_warn(&adapter->pdev->dev,
787  "WARNING: Please make sure external"
788  "loopback connector is plugged in\n");
789  }
790  return -1;
791  }
792  return 0;
793 }
794 
795 static int qlcnic_loopback_test(struct net_device *netdev, u8 mode)
796 {
797  struct qlcnic_adapter *adapter = netdev_priv(netdev);
798  int max_sds_rings = adapter->max_sds_rings;
799  struct qlcnic_host_sds_ring *sds_ring;
800  int loop = 0;
801  int ret;
802 
803  if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_MULTI_LOOPBACK)) {
804  netdev_info(netdev, "Firmware is not loopback test capable\n");
805  return -EOPNOTSUPP;
806  }
807 
808  QLCDB(adapter, DRV, "%s loopback test in progress\n",
809  mode == QLCNIC_ILB_MODE ? "internal" : "external");
810  if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
811  netdev_warn(netdev, "Loopback test not supported for non "
812  "privilege function\n");
813  return 0;
814  }
815 
816  if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
817  return -EBUSY;
818 
819  ret = qlcnic_diag_alloc_res(netdev, QLCNIC_LOOPBACK_TEST);
820  if (ret)
821  goto clear_it;
822 
823  sds_ring = &adapter->recv_ctx->sds_rings[0];
824 
825  ret = qlcnic_set_lb_mode(adapter, mode);
826  if (ret)
827  goto free_res;
828 
829  adapter->diag_cnt = 0;
830  do {
831  msleep(500);
832  qlcnic_process_rcv_ring_diag(sds_ring);
833  if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) {
834  netdev_info(netdev, "firmware didnt respond to loopback"
835  " configure request\n");
836  ret = -QLCNIC_FW_NOT_RESPOND;
837  goto free_res;
838  } else if (adapter->diag_cnt) {
839  ret = adapter->diag_cnt;
840  goto free_res;
841  }
842  } while (!QLCNIC_IS_LB_CONFIGURED(adapter->ahw->loopback_state));
843 
844  ret = qlcnic_do_lb_test(adapter, mode);
845 
846  qlcnic_clear_lb_mode(adapter);
847 
848  free_res:
849  qlcnic_diag_free_res(netdev, max_sds_rings);
850 
851  clear_it:
852  adapter->max_sds_rings = max_sds_rings;
853  clear_bit(__QLCNIC_RESETTING, &adapter->state);
854  return ret;
855 }
856 
857 static void
858 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
859  u64 *data)
860 {
861  memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN);
862 
863  data[0] = qlcnic_reg_test(dev);
864  if (data[0])
865  eth_test->flags |= ETH_TEST_FL_FAILED;
866 
867  data[1] = (u64) qlcnic_test_link(dev);
868  if (data[1])
869  eth_test->flags |= ETH_TEST_FL_FAILED;
870 
871  if (eth_test->flags & ETH_TEST_FL_OFFLINE) {
872  data[2] = qlcnic_irq_test(dev);
873  if (data[2])
874  eth_test->flags |= ETH_TEST_FL_FAILED;
875 
876  data[3] = qlcnic_loopback_test(dev, QLCNIC_ILB_MODE);
877  if (data[3])
878  eth_test->flags |= ETH_TEST_FL_FAILED;
879  if (eth_test->flags & ETH_TEST_FL_EXTERNAL_LB) {
880  data[4] = qlcnic_loopback_test(dev, QLCNIC_ELB_MODE);
881  if (data[4])
882  eth_test->flags |= ETH_TEST_FL_FAILED;
883  eth_test->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE;
884  }
885  }
886 }
887 
888 static void
889 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
890 {
891  struct qlcnic_adapter *adapter = netdev_priv(dev);
892  int index, i, j;
893 
894  switch (stringset) {
895  case ETH_SS_TEST:
896  memcpy(data, *qlcnic_gstrings_test,
897  QLCNIC_TEST_LEN * ETH_GSTRING_LEN);
898  break;
899  case ETH_SS_STATS:
900  for (index = 0; index < QLCNIC_STATS_LEN; index++) {
901  memcpy(data + index * ETH_GSTRING_LEN,
902  qlcnic_gstrings_stats[index].stat_string,
903  ETH_GSTRING_LEN);
904  }
905  for (j = 0; j < QLCNIC_MAC_STATS_LEN; index++, j++) {
906  memcpy(data + index * ETH_GSTRING_LEN,
907  qlcnic_mac_stats_strings[j],
908  ETH_GSTRING_LEN);
909  }
910  if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
911  return;
912  for (i = 0; i < QLCNIC_DEVICE_STATS_LEN; index++, i++) {
913  memcpy(data + index * ETH_GSTRING_LEN,
914  qlcnic_device_gstrings_stats[i],
915  ETH_GSTRING_LEN);
916  }
917  }
918 }
919 
920 static void
921 qlcnic_fill_stats(int *index, u64 *data, void *stats, int type)
922 {
923  int ind = *index;
924 
925  if (type == QLCNIC_MAC_STATS) {
926  struct qlcnic_mac_statistics *mac_stats =
927  (struct qlcnic_mac_statistics *)stats;
928  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_frames);
929  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_bytes);
930  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_mcast_pkts);
931  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_bcast_pkts);
932  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_pause_cnt);
933  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_ctrl_pkt);
934  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_64b_pkts);
935  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_127b_pkts);
936  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_255b_pkts);
937  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_511b_pkts);
938  data[ind++] =
939  QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1023b_pkts);
940  data[ind++] =
941  QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1518b_pkts);
942  data[ind++] =
943  QLCNIC_FILL_STATS(mac_stats->mac_tx_gt_1518b_pkts);
944  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_frames);
945  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_bytes);
946  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_mcast_pkts);
947  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_bcast_pkts);
948  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_pause_cnt);
949  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_ctrl_pkt);
950  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_64b_pkts);
951  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_127b_pkts);
952  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_255b_pkts);
953  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_511b_pkts);
954  data[ind++] =
955  QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1023b_pkts);
956  data[ind++] =
957  QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1518b_pkts);
958  data[ind++] =
959  QLCNIC_FILL_STATS(mac_stats->mac_rx_gt_1518b_pkts);
960  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_error);
961  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_small);
962  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_large);
963  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_jabber);
964  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_dropped);
965  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_rx_crc_error);
966  data[ind++] = QLCNIC_FILL_STATS(mac_stats->mac_align_error);
967  } else if (type == QLCNIC_ESW_STATS) {
968  struct __qlcnic_esw_statistics *esw_stats =
969  (struct __qlcnic_esw_statistics *)stats;
970  data[ind++] = QLCNIC_FILL_STATS(esw_stats->unicast_frames);
971  data[ind++] = QLCNIC_FILL_STATS(esw_stats->multicast_frames);
972  data[ind++] = QLCNIC_FILL_STATS(esw_stats->broadcast_frames);
973  data[ind++] = QLCNIC_FILL_STATS(esw_stats->dropped_frames);
974  data[ind++] = QLCNIC_FILL_STATS(esw_stats->errors);
975  data[ind++] = QLCNIC_FILL_STATS(esw_stats->local_frames);
976  data[ind++] = QLCNIC_FILL_STATS(esw_stats->numbytes);
977  }
978 
979  *index = ind;
980 }
981 
982 static void
983 qlcnic_get_ethtool_stats(struct net_device *dev,
984  struct ethtool_stats *stats, u64 * data)
985 {
986  struct qlcnic_adapter *adapter = netdev_priv(dev);
987  struct qlcnic_esw_statistics port_stats;
988  struct qlcnic_mac_statistics mac_stats;
989  int index, ret;
990 
991  for (index = 0; index < QLCNIC_STATS_LEN; index++) {
992  char *p =
993  (char *)adapter +
994  qlcnic_gstrings_stats[index].stat_offset;
995  data[index] =
996  (qlcnic_gstrings_stats[index].sizeof_stat ==
997  sizeof(u64)) ? *(u64 *)p:(*(u32 *)p);
998  }
999 
1000  /* Retrieve MAC statistics from firmware */
1001  memset(&mac_stats, 0, sizeof(struct qlcnic_mac_statistics));
1002  qlcnic_get_mac_stats(adapter, &mac_stats);
1003  qlcnic_fill_stats(&index, data, &mac_stats, QLCNIC_MAC_STATS);
1004 
1005  if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1006  return;
1007 
1008  memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics));
1009  ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1010  QLCNIC_QUERY_RX_COUNTER, &port_stats.rx);
1011  if (ret)
1012  return;
1013 
1014  qlcnic_fill_stats(&index, data, &port_stats.rx, QLCNIC_ESW_STATS);
1015 
1016  ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1017  QLCNIC_QUERY_TX_COUNTER, &port_stats.tx);
1018  if (ret)
1019  return;
1020 
1021  qlcnic_fill_stats(&index, data, &port_stats.tx, QLCNIC_ESW_STATS);
1022 }
1023 
1024 static int qlcnic_set_led(struct net_device *dev,
1025  enum ethtool_phys_id_state state)
1026 {
1027  struct qlcnic_adapter *adapter = netdev_priv(dev);
1028  int max_sds_rings = adapter->max_sds_rings;
1029  int err = -EIO, active = 1;
1030 
1031  if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
1032  netdev_warn(dev, "LED test not supported for non "
1033  "privilege function\n");
1034  return -EOPNOTSUPP;
1035  }
1036 
1037  switch (state) {
1038  case ETHTOOL_ID_ACTIVE:
1039  if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state))
1040  return -EBUSY;
1041 
1042  if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1043  break;
1044 
1045  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1046  if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1047  break;
1048  set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1049  }
1050 
1051  if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0) {
1052  err = 0;
1053  break;
1054  }
1055 
1056  dev_err(&adapter->pdev->dev,
1057  "Failed to set LED blink state.\n");
1058  break;
1059 
1060  case ETHTOOL_ID_INACTIVE:
1061  active = 0;
1062 
1063  if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1064  break;
1065 
1066  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1067  if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1068  break;
1069  set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1070  }
1071 
1072  if (adapter->nic_ops->config_led(adapter, 0, 0xf))
1073  dev_err(&adapter->pdev->dev,
1074  "Failed to reset LED blink state.\n");
1075 
1076  break;
1077 
1078  default:
1079  return -EINVAL;
1080  }
1081 
1082  if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
1083  qlcnic_diag_free_res(dev, max_sds_rings);
1084 
1085  if (!active || err)
1086  clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
1087 
1088  return err;
1089 }
1090 
1091 static void
1092 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1093 {
1094  struct qlcnic_adapter *adapter = netdev_priv(dev);
1095  u32 wol_cfg;
1096 
1097  wol->supported = 0;
1098  wol->wolopts = 0;
1099 
1100  wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
1101  if (wol_cfg & (1UL << adapter->portnum))
1102  wol->supported |= WAKE_MAGIC;
1103 
1104  wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
1105  if (wol_cfg & (1UL << adapter->portnum))
1106  wol->wolopts |= WAKE_MAGIC;
1107 }
1108 
1109 static int
1110 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1111 {
1112  struct qlcnic_adapter *adapter = netdev_priv(dev);
1113  u32 wol_cfg;
1114 
1115  if (wol->wolopts & ~WAKE_MAGIC)
1116  return -EOPNOTSUPP;
1117 
1118  wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
1119  if (!(wol_cfg & (1 << adapter->portnum)))
1120  return -EOPNOTSUPP;
1121 
1122  wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
1123  if (wol->wolopts & WAKE_MAGIC)
1124  wol_cfg |= 1UL << adapter->portnum;
1125  else
1126  wol_cfg &= ~(1UL << adapter->portnum);
1127 
1128  QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg);
1129 
1130  return 0;
1131 }
1132 
1133 /*
1134  * Set the coalescing parameters. Currently only normal is supported.
1135  * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the
1136  * firmware coalescing to default.
1137  */
1138 static int qlcnic_set_intr_coalesce(struct net_device *netdev,
1139  struct ethtool_coalesce *ethcoal)
1140 {
1141  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1142 
1143  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
1144  return -EINVAL;
1145 
1146  /*
1147  * Return Error if unsupported values or
1148  * unsupported parameters are set.
1149  */
1150  if (ethcoal->rx_coalesce_usecs > 0xffff ||
1151  ethcoal->rx_max_coalesced_frames > 0xffff ||
1152  ethcoal->tx_coalesce_usecs ||
1153  ethcoal->tx_max_coalesced_frames ||
1154  ethcoal->rx_coalesce_usecs_irq ||
1155  ethcoal->rx_max_coalesced_frames_irq ||
1156  ethcoal->tx_coalesce_usecs_irq ||
1157  ethcoal->tx_max_coalesced_frames_irq ||
1158  ethcoal->stats_block_coalesce_usecs ||
1159  ethcoal->use_adaptive_rx_coalesce ||
1160  ethcoal->use_adaptive_tx_coalesce ||
1161  ethcoal->pkt_rate_low ||
1162  ethcoal->rx_coalesce_usecs_low ||
1163  ethcoal->rx_max_coalesced_frames_low ||
1164  ethcoal->tx_coalesce_usecs_low ||
1165  ethcoal->tx_max_coalesced_frames_low ||
1166  ethcoal->pkt_rate_high ||
1167  ethcoal->rx_coalesce_usecs_high ||
1168  ethcoal->rx_max_coalesced_frames_high ||
1169  ethcoal->tx_coalesce_usecs_high ||
1170  ethcoal->tx_max_coalesced_frames_high)
1171  return -EINVAL;
1172 
1173  if (!ethcoal->rx_coalesce_usecs ||
1174  !ethcoal->rx_max_coalesced_frames) {
1175  adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
1176  adapter->ahw->coal.rx_time_us =
1177  QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
1178  adapter->ahw->coal.rx_packets =
1179  QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
1180  } else {
1181  adapter->ahw->coal.flag = 0;
1182  adapter->ahw->coal.rx_time_us = ethcoal->rx_coalesce_usecs;
1183  adapter->ahw->coal.rx_packets =
1184  ethcoal->rx_max_coalesced_frames;
1185  }
1186 
1187  qlcnic_config_intr_coalesce(adapter);
1188 
1189  return 0;
1190 }
1191 
1192 static int qlcnic_get_intr_coalesce(struct net_device *netdev,
1193  struct ethtool_coalesce *ethcoal)
1194 {
1195  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1196 
1197  if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1198  return -EINVAL;
1199 
1200  ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us;
1201  ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets;
1202 
1203  return 0;
1204 }
1205 
1206 static u32 qlcnic_get_msglevel(struct net_device *netdev)
1207 {
1208  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1209 
1210  return adapter->msg_enable;
1211 }
1212 
1213 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl)
1214 {
1215  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1216 
1217  adapter->msg_enable = msglvl;
1218 }
1219 
1220 static int
1221 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
1222 {
1223  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1224  struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1225 
1226  if (!fw_dump->tmpl_hdr) {
1227  netdev_err(adapter->netdev, "FW Dump not supported\n");
1228  return -ENOTSUPP;
1229  }
1230 
1231  if (fw_dump->clr)
1232  dump->len = fw_dump->tmpl_hdr->size + fw_dump->size;
1233  else
1234  dump->len = 0;
1235 
1236  if (!fw_dump->enable)
1237  dump->flag = ETH_FW_DUMP_DISABLE;
1238  else
1239  dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
1240 
1241  dump->version = adapter->fw_version;
1242  return 0;
1243 }
1244 
1245 static int
1246 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
1247  void *buffer)
1248 {
1249  int i, copy_sz;
1250  u32 *hdr_ptr, *data;
1251  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1252  struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1253 
1254  if (!fw_dump->tmpl_hdr) {
1255  netdev_err(netdev, "FW Dump not supported\n");
1256  return -ENOTSUPP;
1257  }
1258 
1259  if (!fw_dump->clr) {
1260  netdev_info(netdev, "Dump not available\n");
1261  return -EINVAL;
1262  }
1263  /* Copy template header first */
1264  copy_sz = fw_dump->tmpl_hdr->size;
1265  hdr_ptr = (u32 *) fw_dump->tmpl_hdr;
1266  data = buffer;
1267  for (i = 0; i < copy_sz/sizeof(u32); i++)
1268  *data++ = cpu_to_le32(*hdr_ptr++);
1269 
1270  /* Copy captured dump data */
1271  memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size);
1272  dump->len = copy_sz + fw_dump->size;
1273  dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
1274 
1275  /* Free dump area once data has been captured */
1276  vfree(fw_dump->data);
1277  fw_dump->data = NULL;
1278  fw_dump->clr = 0;
1279  netdev_info(netdev, "extracted the FW dump Successfully\n");
1280  return 0;
1281 }
1282 
1283 static int
1284 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val)
1285 {
1286  int i;
1287  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1288  struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1289  u32 state;
1290 
1291  switch (val->flag) {
1292  case QLCNIC_FORCE_FW_DUMP_KEY:
1293  if (!fw_dump->tmpl_hdr) {
1294  netdev_err(netdev, "FW dump not supported\n");
1295  return -ENOTSUPP;
1296  }
1297  if (!fw_dump->enable) {
1298  netdev_info(netdev, "FW dump not enabled\n");
1299  return 0;
1300  }
1301  if (fw_dump->clr) {
1302  netdev_info(netdev,
1303  "Previous dump not cleared, not forcing dump\n");
1304  return 0;
1305  }
1306  netdev_info(netdev, "Forcing a FW dump\n");
1307  qlcnic_dev_request_reset(adapter);
1308  break;
1309  case QLCNIC_DISABLE_FW_DUMP:
1310  if (fw_dump->enable && fw_dump->tmpl_hdr) {
1311  netdev_info(netdev, "Disabling FW dump\n");
1312  fw_dump->enable = 0;
1313  }
1314  return 0;
1315  case QLCNIC_ENABLE_FW_DUMP:
1316  if (!fw_dump->tmpl_hdr) {
1317  netdev_err(netdev, "FW dump not supported\n");
1318  return -ENOTSUPP;
1319  }
1320  if (!fw_dump->enable) {
1321  netdev_info(netdev, "Enabling FW dump\n");
1322  fw_dump->enable = 1;
1323  }
1324  return 0;
1325  case QLCNIC_FORCE_FW_RESET:
1326  netdev_info(netdev, "Forcing a FW reset\n");
1327  qlcnic_dev_request_reset(adapter);
1328  adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
1329  return 0;
1330  case QLCNIC_SET_QUIESCENT:
1331  case QLCNIC_RESET_QUIESCENT:
1332  state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
1333  if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD))
1334  netdev_info(netdev, "Device in FAILED state\n");
1335  return 0;
1336  default:
1337  if (!fw_dump->tmpl_hdr) {
1338  netdev_err(netdev, "FW dump not supported\n");
1339  return -ENOTSUPP;
1340  }
1341  for (i = 0; i < ARRAY_SIZE(FW_DUMP_LEVELS); i++) {
1342  if (val->flag == FW_DUMP_LEVELS[i]) {
1343  fw_dump->tmpl_hdr->drv_cap_mask =
1344  val->flag;
1345  netdev_info(netdev, "Driver mask changed to: 0x%x\n",
1346  fw_dump->tmpl_hdr->drv_cap_mask);
1347  return 0;
1348  }
1349  }
1350  netdev_info(netdev, "Invalid dump level: 0x%x\n", val->flag);
1351  return -EINVAL;
1352  }
1353  return 0;
1354 }
1355 
1356 const struct ethtool_ops qlcnic_ethtool_ops = {
1357  .get_settings = qlcnic_get_settings,
1358  .set_settings = qlcnic_set_settings,
1359  .get_drvinfo = qlcnic_get_drvinfo,
1360  .get_regs_len = qlcnic_get_regs_len,
1361  .get_regs = qlcnic_get_regs,
1362  .get_link = ethtool_op_get_link,
1363  .get_eeprom_len = qlcnic_get_eeprom_len,
1364  .get_eeprom = qlcnic_get_eeprom,
1365  .get_ringparam = qlcnic_get_ringparam,
1366  .set_ringparam = qlcnic_set_ringparam,
1367  .get_channels = qlcnic_get_channels,
1368  .set_channels = qlcnic_set_channels,
1369  .get_pauseparam = qlcnic_get_pauseparam,
1370  .set_pauseparam = qlcnic_set_pauseparam,
1371  .get_wol = qlcnic_get_wol,
1372  .set_wol = qlcnic_set_wol,
1373  .self_test = qlcnic_diag_test,
1374  .get_strings = qlcnic_get_strings,
1375  .get_ethtool_stats = qlcnic_get_ethtool_stats,
1376  .get_sset_count = qlcnic_get_sset_count,
1377  .get_coalesce = qlcnic_get_intr_coalesce,
1378  .set_coalesce = qlcnic_set_intr_coalesce,
1379  .set_phys_id = qlcnic_set_led,
1380  .set_msglevel = qlcnic_set_msglevel,
1381  .get_msglevel = qlcnic_get_msglevel,
1382  .get_dump_flag = qlcnic_get_dump_flag,
1383  .get_dump_data = qlcnic_get_dump_data,
1384  .set_dump = qlcnic_set_dump,
1385 };
1386 
1387 const struct ethtool_ops qlcnic_ethtool_failed_ops = {
1388  .get_settings = qlcnic_get_settings,
1389  .get_drvinfo = qlcnic_get_drvinfo,
1390  .set_msglevel = qlcnic_set_msglevel,
1391  .get_msglevel = qlcnic_get_msglevel,
1392 };
Generated on Thu Jan 10 2013 14:04:21 for Linux Kernel by   doxygen 1.8.2