?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add linux-next specific files for 20110831
[linux-2.6/next.git] / drivers / net / ethernet / qlogic / qlcnic / qlcnic_ethtool.c
blobb127f809421b8dac3acca2c5558f1ed3adb0ddac
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 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
144
145 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
146 strlcpy(drvinfo->driver, qlcnic_driver_name, 32);
147 strlcpy(drvinfo->version, QLCNIC_LINUX_VERSIONID, 32);
148 }
149
150 static int
151 qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
152 {
153 struct qlcnic_adapter *adapter = netdev_priv(dev);
154 int check_sfp_module = 0;
155 u16 pcifn = adapter->ahw->pci_func;
156
157 /* read which mode */
158 if (adapter->ahw->port_type == QLCNIC_GBE) {
159 ecmd->supported = (SUPPORTED_10baseT_Half |
160 SUPPORTED_10baseT_Full |
161 SUPPORTED_100baseT_Half |
162 SUPPORTED_100baseT_Full |
163 SUPPORTED_1000baseT_Half |
164 SUPPORTED_1000baseT_Full);
165
166 ecmd->advertising = (ADVERTISED_100baseT_Half |
167 ADVERTISED_100baseT_Full |
168 ADVERTISED_1000baseT_Half |
169 ADVERTISED_1000baseT_Full);
170
171 ethtool_cmd_speed_set(ecmd, adapter->link_speed);
172 ecmd->duplex = adapter->link_duplex;
173 ecmd->autoneg = adapter->link_autoneg;
174
175 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
176 u32 val;
177
178 val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR);
179 if (val == QLCNIC_PORT_MODE_802_3_AP) {
180 ecmd->supported = SUPPORTED_1000baseT_Full;
181 ecmd->advertising = ADVERTISED_1000baseT_Full;
182 } else {
183 ecmd->supported = SUPPORTED_10000baseT_Full;
184 ecmd->advertising = ADVERTISED_10000baseT_Full;
185 }
186
187 if (netif_running(dev) && adapter->has_link_events) {
188 ethtool_cmd_speed_set(ecmd, adapter->link_speed);
189 ecmd->autoneg = adapter->link_autoneg;
190 ecmd->duplex = adapter->link_duplex;
191 goto skip;
192 }
193
194 val = QLCRD32(adapter, P3P_LINK_SPEED_REG(pcifn));
195 ethtool_cmd_speed_set(ecmd, P3P_LINK_SPEED_MHZ *
196 P3P_LINK_SPEED_VAL(pcifn, val));
197 ecmd->duplex = DUPLEX_FULL;
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 ring->rx_mini_max_pending = 0;
423 ring->rx_mini_pending = 0;
424 }
425
426 static u32
427 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name)
428 {
429 u32 num_desc;
430 num_desc = max(val, min);
431 num_desc = min(num_desc, max);
432 num_desc = roundup_pow_of_two(num_desc);
433
434 if (val != num_desc) {
435 printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n",
436 qlcnic_driver_name, r_name, num_desc, val);
437 }
438
439 return num_desc;
440 }
441
442 static int
443 qlcnic_set_ringparam(struct net_device *dev,
444 struct ethtool_ringparam *ring)
445 {
446 struct qlcnic_adapter *adapter = netdev_priv(dev);
447 u16 num_rxd, num_jumbo_rxd, num_txd;
448
449 if (ring->rx_mini_pending)
450 return -EOPNOTSUPP;
451
452 num_rxd = qlcnic_validate_ringparam(ring->rx_pending,
453 MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx");
454
455 num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending,
456 MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd,
457 "rx jumbo");
458
459 num_txd = qlcnic_validate_ringparam(ring->tx_pending,
460 MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx");
461
462 if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd &&
463 num_jumbo_rxd == adapter->num_jumbo_rxd)
464 return 0;
465
466 adapter->num_rxd = num_rxd;
467 adapter->num_jumbo_rxd = num_jumbo_rxd;
468 adapter->num_txd = num_txd;
469
470 return qlcnic_reset_context(adapter);
471 }
472
473 static void qlcnic_get_channels(struct net_device *dev,
474 struct ethtool_channels *channel)
475 {
476 struct qlcnic_adapter *adapter = netdev_priv(dev);
477
478 channel->max_rx = rounddown_pow_of_two(min_t(int,
479 adapter->max_rx_ques, num_online_cpus()));
480 channel->max_tx = adapter->max_tx_ques;
481
482 channel->rx_count = adapter->max_sds_rings;
483 channel->tx_count = adapter->max_tx_ques;
484 }
485
486 static int qlcnic_set_channels(struct net_device *dev,
487 struct ethtool_channels *channel)
488 {
489 struct qlcnic_adapter *adapter = netdev_priv(dev);
490 int err;
491
492 if (channel->other_count || channel->combined_count ||
493 channel->tx_count != channel->max_tx)
494 return -EINVAL;
495
496 err = qlcnic_validate_max_rss(dev, channel->max_rx, channel->rx_count);
497 if (err)
498 return err;
499
500 err = qlcnic_set_max_rss(adapter, channel->rx_count);
501 netdev_info(dev, "allocated 0x%x sds rings\n",
502 adapter->max_sds_rings);
503 return err;
504 }
505
506 static void
507 qlcnic_get_pauseparam(struct net_device *netdev,
508 struct ethtool_pauseparam *pause)
509 {
510 struct qlcnic_adapter *adapter = netdev_priv(netdev);
511 int port = adapter->physical_port;
512 __u32 val;
513
514 if (adapter->ahw->port_type == QLCNIC_GBE) {
515 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
516 return;
517 /* get flow control settings */
518 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
519 pause->rx_pause = qlcnic_gb_get_rx_flowctl(val);
520 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
521 switch (port) {
522 case 0:
523 pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val));
524 break;
525 case 1:
526 pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val));
527 break;
528 case 2:
529 pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val));
530 break;
531 case 3:
532 default:
533 pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val));
534 break;
535 }
536 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
537 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
538 return;
539 pause->rx_pause = 1;
540 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
541 if (port == 0)
542 pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val));
543 else
544 pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val));
545 } else {
546 dev_err(&netdev->dev, "Unknown board type: %x\n",
547 adapter->ahw->port_type);
548 }
549 }
550
551 static int
552 qlcnic_set_pauseparam(struct net_device *netdev,
553 struct ethtool_pauseparam *pause)
554 {
555 struct qlcnic_adapter *adapter = netdev_priv(netdev);
556 int port = adapter->physical_port;
557 __u32 val;
558
559 /* read mode */
560 if (adapter->ahw->port_type == QLCNIC_GBE) {
561 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
562 return -EIO;
563 /* set flow control */
564 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
565
566 if (pause->rx_pause)
567 qlcnic_gb_rx_flowctl(val);
568 else
569 qlcnic_gb_unset_rx_flowctl(val);
570
571 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port),
572 val);
573 /* set autoneg */
574 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
575 switch (port) {
576 case 0:
577 if (pause->tx_pause)
578 qlcnic_gb_unset_gb0_mask(val);
579 else
580 qlcnic_gb_set_gb0_mask(val);
581 break;
582 case 1:
583 if (pause->tx_pause)
584 qlcnic_gb_unset_gb1_mask(val);
585 else
586 qlcnic_gb_set_gb1_mask(val);
587 break;
588 case 2:
589 if (pause->tx_pause)
590 qlcnic_gb_unset_gb2_mask(val);
591 else
592 qlcnic_gb_set_gb2_mask(val);
593 break;
594 case 3:
595 default:
596 if (pause->tx_pause)
597 qlcnic_gb_unset_gb3_mask(val);
598 else
599 qlcnic_gb_set_gb3_mask(val);
600 break;
601 }
602 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val);
603 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
604 if (!pause->rx_pause || pause->autoneg)
605 return -EOPNOTSUPP;
606
607 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
608 return -EIO;
609
610 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
611 if (port == 0) {
612 if (pause->tx_pause)
613 qlcnic_xg_unset_xg0_mask(val);
614 else
615 qlcnic_xg_set_xg0_mask(val);
616 } else {
617 if (pause->tx_pause)
618 qlcnic_xg_unset_xg1_mask(val);
619 else
620 qlcnic_xg_set_xg1_mask(val);
621 }
622 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val);
623 } else {
624 dev_err(&netdev->dev, "Unknown board type: %x\n",
625 adapter->ahw->port_type);
626 }
627 return 0;
628 }
629
630 static int qlcnic_reg_test(struct net_device *dev)
631 {
632 struct qlcnic_adapter *adapter = netdev_priv(dev);
633 u32 data_read;
634
635 data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0));
636 if ((data_read & 0xffff) != adapter->pdev->vendor)
637 return 1;
638
639 return 0;
640 }
641
642 static int qlcnic_get_sset_count(struct net_device *dev, int sset)
643 {
644 struct qlcnic_adapter *adapter = netdev_priv(dev);
645 switch (sset) {
646 case ETH_SS_TEST:
647 return QLCNIC_TEST_LEN;
648 case ETH_SS_STATS:
649 if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
650 return QLCNIC_STATS_LEN + QLCNIC_DEVICE_STATS_LEN;
651 return QLCNIC_STATS_LEN;
652 default:
653 return -EOPNOTSUPP;
654 }
655 }
656
657 static int qlcnic_irq_test(struct net_device *netdev)
658 {
659 struct qlcnic_adapter *adapter = netdev_priv(netdev);
660 int max_sds_rings = adapter->max_sds_rings;
661 int ret;
662 u32 *rd_args[3];
663
664 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
665 return -EIO;
666
667 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST);
668 if (ret)
669 goto clear_it;
670
671 adapter->diag_cnt = 0;
672 memset(rd_args, 0, sizeof(rd_args));
673 ret = qlcnic_issue_cmd(adapter, adapter->ahw->pci_func,
674 adapter->fw_hal_version, adapter->ahw->pci_func,
675 0, 0, 0x00000011, rd_args);
676 if (ret)
677 goto done;
678
679 msleep(10);
680
681 ret = !adapter->diag_cnt;
682
683 done:
684 qlcnic_diag_free_res(netdev, max_sds_rings);
685
686 clear_it:
687 adapter->max_sds_rings = max_sds_rings;
688 clear_bit(__QLCNIC_RESETTING, &adapter->state);
689 return ret;
690 }
691
692 #define QLCNIC_ILB_PKT_SIZE 64
693 #define QLCNIC_NUM_ILB_PKT 16
694 #define QLCNIC_ILB_MAX_RCV_LOOP 10
695
696 static void qlcnic_create_loopback_buff(unsigned char *data, u8 mac[])
697 {
698 unsigned char random_data[] = {0xa8, 0x06, 0x45, 0x00};
699
700 memset(data, 0x4e, QLCNIC_ILB_PKT_SIZE);
701
702 memcpy(data, mac, ETH_ALEN);
703 memcpy(data + ETH_ALEN, mac, ETH_ALEN);
704
705 memcpy(data + 2 * ETH_ALEN, random_data, sizeof(random_data));
706 }
707
708 int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[])
709 {
710 unsigned char buff[QLCNIC_ILB_PKT_SIZE];
711 qlcnic_create_loopback_buff(buff, mac);
712 return memcmp(data, buff, QLCNIC_ILB_PKT_SIZE);
713 }
714
715 static int qlcnic_do_lb_test(struct qlcnic_adapter *adapter, u8 mode)
716 {
717 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
718 struct qlcnic_host_sds_ring *sds_ring = &recv_ctx->sds_rings[0];
719 struct sk_buff *skb;
720 int i, loop, cnt = 0;
721
722 for (i = 0; i < QLCNIC_NUM_ILB_PKT; i++) {
723 skb = dev_alloc_skb(QLCNIC_ILB_PKT_SIZE);
724 qlcnic_create_loopback_buff(skb->data, adapter->mac_addr);
725 skb_put(skb, QLCNIC_ILB_PKT_SIZE);
726
727 adapter->diag_cnt = 0;
728 qlcnic_xmit_frame(skb, adapter->netdev);
729
730 loop = 0;
731 do {
732 msleep(1);
733 qlcnic_process_rcv_ring_diag(sds_ring);
734 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP)
735 break;
736 } while (!adapter->diag_cnt);
737
738 dev_kfree_skb_any(skb);
739
740 if (!adapter->diag_cnt)
741 QLCDB(adapter, DRV,
742 "LB Test: packet #%d was not received\n", i + 1);
743 else
744 cnt++;
745 }
746 if (cnt != i) {
747 dev_warn(&adapter->pdev->dev, "LB Test failed\n");
748 if (mode != QLCNIC_ILB_MODE) {
749 dev_warn(&adapter->pdev->dev,
750 "WARNING: Please make sure external"
751 "loopback connector is plugged in\n");
752 }
753 return -1;
754 }
755 return 0;
756 }
757
758 static int qlcnic_loopback_test(struct net_device *netdev, u8 mode)
759 {
760 struct qlcnic_adapter *adapter = netdev_priv(netdev);
761 int max_sds_rings = adapter->max_sds_rings;
762 struct qlcnic_host_sds_ring *sds_ring;
763 int loop = 0;
764 int ret;
765
766 if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_MULTI_LOOPBACK)) {
767 netdev_info(netdev, "Firmware is not loopback test capable\n");
768 return -EOPNOTSUPP;
769 }
770
771 QLCDB(adapter, DRV, "%s loopback test in progress\n",
772 mode == QLCNIC_ILB_MODE ? "internal" : "external");
773 if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
774 netdev_warn(netdev, "Loopback test not supported for non "
775 "privilege function\n");
776 return 0;
777 }
778
779 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
780 return -EBUSY;
781
782 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_LOOPBACK_TEST);
783 if (ret)
784 goto clear_it;
785
786 sds_ring = &adapter->recv_ctx->sds_rings[0];
787
788 ret = qlcnic_set_lb_mode(adapter, mode);
789 if (ret)
790 goto free_res;
791
792 adapter->diag_cnt = 0;
793 do {
794 msleep(500);
795 qlcnic_process_rcv_ring_diag(sds_ring);
796 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) {
797 netdev_info(netdev, "firmware didnt respond to loopback"
798 " configure request\n");
799 ret = -QLCNIC_FW_NOT_RESPOND;
800 goto free_res;
801 } else if (adapter->diag_cnt) {
802 ret = adapter->diag_cnt;
803 goto free_res;
804 }
805 } while (!QLCNIC_IS_LB_CONFIGURED(adapter->ahw->loopback_state));
806
807 ret = qlcnic_do_lb_test(adapter, mode);
808
809 qlcnic_clear_lb_mode(adapter);
810
811 free_res:
812 qlcnic_diag_free_res(netdev, max_sds_rings);
813
814 clear_it:
815 adapter->max_sds_rings = max_sds_rings;
816 clear_bit(__QLCNIC_RESETTING, &adapter->state);
817 return ret;
818 }
819
820 static void
821 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
822 u64 *data)
823 {
824 memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN);
825
826 data[0] = qlcnic_reg_test(dev);
827 if (data[0])
828 eth_test->flags |= ETH_TEST_FL_FAILED;
829
830 data[1] = (u64) qlcnic_test_link(dev);
831 if (data[1])
832 eth_test->flags |= ETH_TEST_FL_FAILED;
833
834 if (eth_test->flags & ETH_TEST_FL_OFFLINE) {
835 data[2] = qlcnic_irq_test(dev);
836 if (data[2])
837 eth_test->flags |= ETH_TEST_FL_FAILED;
838
839 data[3] = qlcnic_loopback_test(dev, QLCNIC_ILB_MODE);
840 if (data[3])
841 eth_test->flags |= ETH_TEST_FL_FAILED;
842 if (eth_test->flags & ETH_TEST_FL_EXTERNAL_LB) {
843 data[4] = qlcnic_loopback_test(dev, QLCNIC_ELB_MODE);
844 if (data[4])
845 eth_test->flags |= ETH_TEST_FL_FAILED;
846 eth_test->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE;
847 }
848 }
849 }
850
851 static void
852 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
853 {
854 struct qlcnic_adapter *adapter = netdev_priv(dev);
855 int index, i;
856
857 switch (stringset) {
858 case ETH_SS_TEST:
859 memcpy(data, *qlcnic_gstrings_test,
860 QLCNIC_TEST_LEN * ETH_GSTRING_LEN);
861 break;
862 case ETH_SS_STATS:
863 for (index = 0; index < QLCNIC_STATS_LEN; index++) {
864 memcpy(data + index * ETH_GSTRING_LEN,
865 qlcnic_gstrings_stats[index].stat_string,
866 ETH_GSTRING_LEN);
867 }
868 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
869 return;
870 for (i = 0; i < QLCNIC_DEVICE_STATS_LEN; index++, i++) {
871 memcpy(data + index * ETH_GSTRING_LEN,
872 qlcnic_device_gstrings_stats[i],
873 ETH_GSTRING_LEN);
874 }
875 }
876 }
877
878 #define QLCNIC_FILL_ESWITCH_STATS(VAL1) \
879 (((VAL1) == QLCNIC_ESW_STATS_NOT_AVAIL) ? 0 : VAL1)
880
881 static void
882 qlcnic_fill_device_stats(int *index, u64 *data,
883 struct __qlcnic_esw_statistics *stats)
884 {
885 int ind = *index;
886
887 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->unicast_frames);
888 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->multicast_frames);
889 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->broadcast_frames);
890 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->dropped_frames);
891 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->errors);
892 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->local_frames);
893 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->numbytes);
894
895 *index = ind;
896 }
897
898 static void
899 qlcnic_get_ethtool_stats(struct net_device *dev,
900 struct ethtool_stats *stats, u64 * data)
901 {
902 struct qlcnic_adapter *adapter = netdev_priv(dev);
903 struct qlcnic_esw_statistics port_stats;
904 int index, ret;
905
906 for (index = 0; index < QLCNIC_STATS_LEN; index++) {
907 char *p =
908 (char *)adapter +
909 qlcnic_gstrings_stats[index].stat_offset;
910 data[index] =
911 (qlcnic_gstrings_stats[index].sizeof_stat ==
912 sizeof(u64)) ? *(u64 *)p:(*(u32 *)p);
913 }
914
915 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
916 return;
917
918 memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics));
919 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
920 QLCNIC_QUERY_RX_COUNTER, &port_stats.rx);
921 if (ret)
922 return;
923
924 qlcnic_fill_device_stats(&index, data, &port_stats.rx);
925
926 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
927 QLCNIC_QUERY_TX_COUNTER, &port_stats.tx);
928 if (ret)
929 return;
930
931 qlcnic_fill_device_stats(&index, data, &port_stats.tx);
932 }
933
934 static int qlcnic_set_led(struct net_device *dev,
935 enum ethtool_phys_id_state state)
936 {
937 struct qlcnic_adapter *adapter = netdev_priv(dev);
938 int max_sds_rings = adapter->max_sds_rings;
939
940 switch (state) {
941 case ETHTOOL_ID_ACTIVE:
942 if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state))
943 return -EBUSY;
944
945 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
946 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
947 return -EIO;
948
949 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST)) {
950 clear_bit(__QLCNIC_RESETTING, &adapter->state);
951 return -EIO;
952 }
953 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
954 }
955
956 if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0)
957 return 0;
958
959 dev_err(&adapter->pdev->dev,
960 "Failed to set LED blink state.\n");
961 break;
962
963 case ETHTOOL_ID_INACTIVE:
964 if (adapter->nic_ops->config_led(adapter, 0, 0xf))
965 dev_err(&adapter->pdev->dev,
966 "Failed to reset LED blink state.\n");
967
968 break;
969
970 default:
971 return -EINVAL;
972 }
973
974 if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state)) {
975 qlcnic_diag_free_res(dev, max_sds_rings);
976 clear_bit(__QLCNIC_RESETTING, &adapter->state);
977 }
978
979 clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
980
981 return -EIO;
982 }
983
984 static void
985 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
986 {
987 struct qlcnic_adapter *adapter = netdev_priv(dev);
988 u32 wol_cfg;
989
990 wol->supported = 0;
991 wol->wolopts = 0;
992
993 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
994 if (wol_cfg & (1UL << adapter->portnum))
995 wol->supported |= WAKE_MAGIC;
996
997 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
998 if (wol_cfg & (1UL << adapter->portnum))
999 wol->wolopts |= WAKE_MAGIC;
1000 }
1001
1002 static int
1003 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1004 {
1005 struct qlcnic_adapter *adapter = netdev_priv(dev);
1006 u32 wol_cfg;
1007
1008 if (wol->wolopts & ~WAKE_MAGIC)
1009 return -EOPNOTSUPP;
1010
1011 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
1012 if (!(wol_cfg & (1 << adapter->portnum)))
1013 return -EOPNOTSUPP;
1014
1015 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
1016 if (wol->wolopts & WAKE_MAGIC)
1017 wol_cfg |= 1UL << adapter->portnum;
1018 else
1019 wol_cfg &= ~(1UL << adapter->portnum);
1020
1021 QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg);
1022
1023 return 0;
1024 }
1025
1026 /*
1027 * Set the coalescing parameters. Currently only normal is supported.
1028 * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the
1029 * firmware coalescing to default.
1030 */
1031 static int qlcnic_set_intr_coalesce(struct net_device *netdev,
1032 struct ethtool_coalesce *ethcoal)
1033 {
1034 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1035
1036 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
1037 return -EINVAL;
1038
1039 /*
1040 * Return Error if unsupported values or
1041 * unsupported parameters are set.
1042 */
1043 if (ethcoal->rx_coalesce_usecs > 0xffff ||
1044 ethcoal->rx_max_coalesced_frames > 0xffff ||
1045 ethcoal->tx_coalesce_usecs ||
1046 ethcoal->tx_max_coalesced_frames ||
1047 ethcoal->rx_coalesce_usecs_irq ||
1048 ethcoal->rx_max_coalesced_frames_irq ||
1049 ethcoal->tx_coalesce_usecs_irq ||
1050 ethcoal->tx_max_coalesced_frames_irq ||
1051 ethcoal->stats_block_coalesce_usecs ||
1052 ethcoal->use_adaptive_rx_coalesce ||
1053 ethcoal->use_adaptive_tx_coalesce ||
1054 ethcoal->pkt_rate_low ||
1055 ethcoal->rx_coalesce_usecs_low ||
1056 ethcoal->rx_max_coalesced_frames_low ||
1057 ethcoal->tx_coalesce_usecs_low ||
1058 ethcoal->tx_max_coalesced_frames_low ||
1059 ethcoal->pkt_rate_high ||
1060 ethcoal->rx_coalesce_usecs_high ||
1061 ethcoal->rx_max_coalesced_frames_high ||
1062 ethcoal->tx_coalesce_usecs_high ||
1063 ethcoal->tx_max_coalesced_frames_high)
1064 return -EINVAL;
1065
1066 if (!ethcoal->rx_coalesce_usecs ||
1067 !ethcoal->rx_max_coalesced_frames) {
1068 adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
1069 adapter->ahw->coal.rx_time_us =
1070 QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
1071 adapter->ahw->coal.rx_packets =
1072 QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
1073 } else {
1074 adapter->ahw->coal.flag = 0;
1075 adapter->ahw->coal.rx_time_us = ethcoal->rx_coalesce_usecs;
1076 adapter->ahw->coal.rx_packets =
1077 ethcoal->rx_max_coalesced_frames;
1078 }
1079
1080 qlcnic_config_intr_coalesce(adapter);
1081
1082 return 0;
1083 }
1084
1085 static int qlcnic_get_intr_coalesce(struct net_device *netdev,
1086 struct ethtool_coalesce *ethcoal)
1087 {
1088 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1089
1090 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1091 return -EINVAL;
1092
1093 ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us;
1094 ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets;
1095
1096 return 0;
1097 }
1098
1099 static u32 qlcnic_get_msglevel(struct net_device *netdev)
1100 {
1101 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1102
1103 return adapter->msg_enable;
1104 }
1105
1106 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl)
1107 {
1108 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1109
1110 adapter->msg_enable = msglvl;
1111 }
1112
1113 static int
1114 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
1115 {
1116 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1117 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1118
1119 if (fw_dump->clr)
1120 dump->len = fw_dump->tmpl_hdr->size + fw_dump->size;
1121 else
1122 dump->len = 0;
1123 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
1124 dump->version = adapter->fw_version;
1125 return 0;
1126 }
1127
1128 static int
1129 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
1130 void *buffer)
1131 {
1132 int i, copy_sz;
1133 u32 *hdr_ptr, *data;
1134 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1135 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1136
1137 if (!fw_dump->clr) {
1138 netdev_info(netdev, "Dump not available\n");
1139 qlcnic_api_unlock(adapter);
1140 return -EINVAL;
1141 }
1142 /* Copy template header first */
1143 copy_sz = fw_dump->tmpl_hdr->size;
1144 hdr_ptr = (u32 *) fw_dump->tmpl_hdr;
1145 data = buffer;
1146 for (i = 0; i < copy_sz/sizeof(u32); i++)
1147 *data++ = cpu_to_le32(*hdr_ptr++);
1148
1149 /* Copy captured dump data */
1150 memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size);
1151 dump->len = copy_sz + fw_dump->size;
1152 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
1153
1154 /* Free dump area once data has been captured */
1155 vfree(fw_dump->data);
1156 fw_dump->data = NULL;
1157 fw_dump->clr = 0;
1158
1159 return 0;
1160 }
1161
1162 static int
1163 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val)
1164 {
1165 int ret = 0;
1166 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1167 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1168
1169 switch (val->flag) {
1170 case QLCNIC_FORCE_FW_DUMP_KEY:
1171 if (!fw_dump->enable) {
1172 netdev_info(netdev, "FW dump not enabled\n");
1173 return ret;
1174 }
1175 if (fw_dump->clr) {
1176 dev_info(&adapter->pdev->dev,
1177 "Previous dump not cleared, not forcing dump\n");
1178 return ret;
1179 }
1180 netdev_info(netdev, "Forcing a FW dump\n");
1181 qlcnic_dev_request_reset(adapter);
1182 break;
1183 case QLCNIC_DISABLE_FW_DUMP:
1184 if (fw_dump->enable) {
1185 netdev_info(netdev, "Disabling FW dump\n");
1186 fw_dump->enable = 0;
1187 }
1188 break;
1189 case QLCNIC_ENABLE_FW_DUMP:
1190 if (!fw_dump->enable && fw_dump->tmpl_hdr) {
1191 netdev_info(netdev, "Enabling FW dump\n");
1192 fw_dump->enable = 1;
1193 }
1194 break;
1195 case QLCNIC_FORCE_FW_RESET:
1196 netdev_info(netdev, "Forcing a FW reset\n");
1197 qlcnic_dev_request_reset(adapter);
1198 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
1199 break;
1200 default:
1201 if (val->flag > QLCNIC_DUMP_MASK_MAX ||
1202 val->flag < QLCNIC_DUMP_MASK_MIN) {
1203 netdev_info(netdev,
1204 "Invalid dump level: 0x%x\n", val->flag);
1205 ret = -EINVAL;
1206 goto out;
1207 }
1208 fw_dump->tmpl_hdr->drv_cap_mask = val->flag & 0xff;
1209 netdev_info(netdev, "Driver mask changed to: 0x%x\n",
1210 fw_dump->tmpl_hdr->drv_cap_mask);
1211 }
1212 out:
1213 return ret;
1214 }
1215
1216 const struct ethtool_ops qlcnic_ethtool_ops = {
1217 .get_settings = qlcnic_get_settings,
1218 .set_settings = qlcnic_set_settings,
1219 .get_drvinfo = qlcnic_get_drvinfo,
1220 .get_regs_len = qlcnic_get_regs_len,
1221 .get_regs = qlcnic_get_regs,
1222 .get_link = ethtool_op_get_link,
1223 .get_eeprom_len = qlcnic_get_eeprom_len,
1224 .get_eeprom = qlcnic_get_eeprom,
1225 .get_ringparam = qlcnic_get_ringparam,
1226 .set_ringparam = qlcnic_set_ringparam,
1227 .get_channels = qlcnic_get_channels,
1228 .set_channels = qlcnic_set_channels,
1229 .get_pauseparam = qlcnic_get_pauseparam,
1230 .set_pauseparam = qlcnic_set_pauseparam,
1231 .get_wol = qlcnic_get_wol,
1232 .set_wol = qlcnic_set_wol,
1233 .self_test = qlcnic_diag_test,
1234 .get_strings = qlcnic_get_strings,
1235 .get_ethtool_stats = qlcnic_get_ethtool_stats,
1236 .get_sset_count = qlcnic_get_sset_count,
1237 .get_coalesce = qlcnic_get_intr_coalesce,
1238 .set_coalesce = qlcnic_set_intr_coalesce,
1239 .set_phys_id = qlcnic_set_led,
1240 .set_msglevel = qlcnic_set_msglevel,
1241 .get_msglevel = qlcnic_get_msglevel,
1242 .get_dump_flag = qlcnic_get_dump_flag,
1243 .get_dump_data = qlcnic_get_dump_data,
1244 .set_dump = qlcnic_set_dump,
1245 };
linux-next