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