]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c
projects / thirdparty / kernel / stable.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge drm/drm-next into drm-intel-next-queued
[thirdparty/kernel/stable.git] / drivers / net / ethernet / qlogic / qlcnic / qlcnic_ethtool.c
1 /*
2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2013 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 static const u32 qlcnic_fw_dump_level[] = {
26 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff
27 };
28
29 static const struct qlcnic_stats qlcnic_gstrings_stats[] = {
30 {"xmit_on", QLC_SIZEOF(stats.xmit_on), QLC_OFF(stats.xmit_on)},
31 {"xmit_off", QLC_SIZEOF(stats.xmit_off), QLC_OFF(stats.xmit_off)},
32 {"xmit_called", QLC_SIZEOF(stats.xmitcalled),
33 QLC_OFF(stats.xmitcalled)},
34 {"xmit_finished", QLC_SIZEOF(stats.xmitfinished),
35 QLC_OFF(stats.xmitfinished)},
36 {"tx dma map error", QLC_SIZEOF(stats.tx_dma_map_error),
37 QLC_OFF(stats.tx_dma_map_error)},
38 {"tx_bytes", QLC_SIZEOF(stats.txbytes), QLC_OFF(stats.txbytes)},
39 {"tx_dropped", QLC_SIZEOF(stats.txdropped), QLC_OFF(stats.txdropped)},
40 {"rx dma map error", QLC_SIZEOF(stats.rx_dma_map_error),
41 QLC_OFF(stats.rx_dma_map_error)},
42 {"rx_pkts", QLC_SIZEOF(stats.rx_pkts), QLC_OFF(stats.rx_pkts)},
43 {"rx_bytes", QLC_SIZEOF(stats.rxbytes), QLC_OFF(stats.rxbytes)},
44 {"rx_dropped", QLC_SIZEOF(stats.rxdropped), QLC_OFF(stats.rxdropped)},
45 {"null rxbuf", QLC_SIZEOF(stats.null_rxbuf), QLC_OFF(stats.null_rxbuf)},
46 {"csummed", QLC_SIZEOF(stats.csummed), QLC_OFF(stats.csummed)},
47 {"lro_pkts", QLC_SIZEOF(stats.lro_pkts), QLC_OFF(stats.lro_pkts)},
48 {"lrobytes", QLC_SIZEOF(stats.lrobytes), QLC_OFF(stats.lrobytes)},
49 {"lso_frames", QLC_SIZEOF(stats.lso_frames), QLC_OFF(stats.lso_frames)},
50 {"encap_lso_frames", QLC_SIZEOF(stats.encap_lso_frames),
51 QLC_OFF(stats.encap_lso_frames)},
52 {"encap_tx_csummed", QLC_SIZEOF(stats.encap_tx_csummed),
53 QLC_OFF(stats.encap_tx_csummed)},
54 {"encap_rx_csummed", QLC_SIZEOF(stats.encap_rx_csummed),
55 QLC_OFF(stats.encap_rx_csummed)},
56 {"skb_alloc_failure", QLC_SIZEOF(stats.skb_alloc_failure),
57 QLC_OFF(stats.skb_alloc_failure)},
58 {"mac_filter_limit_overrun", QLC_SIZEOF(stats.mac_filter_limit_overrun),
59 QLC_OFF(stats.mac_filter_limit_overrun)},
60 {"spurious intr", QLC_SIZEOF(stats.spurious_intr),
61 QLC_OFF(stats.spurious_intr)},
62 {"mbx spurious intr", QLC_SIZEOF(stats.mbx_spurious_intr),
63 QLC_OFF(stats.mbx_spurious_intr)},
64 };
65
66 static const char qlcnic_device_gstrings_stats[][ETH_GSTRING_LEN] = {
67 "tx unicast frames",
68 "tx multicast frames",
69 "tx broadcast frames",
70 "tx dropped frames",
71 "tx errors",
72 "tx local frames",
73 "tx numbytes",
74 "rx unicast frames",
75 "rx multicast frames",
76 "rx broadcast frames",
77 "rx dropped frames",
78 "rx errors",
79 "rx local frames",
80 "rx numbytes",
81 };
82
83 static const char qlcnic_83xx_tx_stats_strings[][ETH_GSTRING_LEN] = {
84 "ctx_tx_bytes",
85 "ctx_tx_pkts",
86 "ctx_tx_errors",
87 "ctx_tx_dropped_pkts",
88 "ctx_tx_num_buffers",
89 };
90
91 static const char qlcnic_83xx_mac_stats_strings[][ETH_GSTRING_LEN] = {
92 "mac_tx_frames",
93 "mac_tx_bytes",
94 "mac_tx_mcast_pkts",
95 "mac_tx_bcast_pkts",
96 "mac_tx_pause_cnt",
97 "mac_tx_ctrl_pkt",
98 "mac_tx_lt_64b_pkts",
99 "mac_tx_lt_127b_pkts",
100 "mac_tx_lt_255b_pkts",
101 "mac_tx_lt_511b_pkts",
102 "mac_tx_lt_1023b_pkts",
103 "mac_tx_lt_1518b_pkts",
104 "mac_tx_gt_1518b_pkts",
105 "mac_rx_frames",
106 "mac_rx_bytes",
107 "mac_rx_mcast_pkts",
108 "mac_rx_bcast_pkts",
109 "mac_rx_pause_cnt",
110 "mac_rx_ctrl_pkt",
111 "mac_rx_lt_64b_pkts",
112 "mac_rx_lt_127b_pkts",
113 "mac_rx_lt_255b_pkts",
114 "mac_rx_lt_511b_pkts",
115 "mac_rx_lt_1023b_pkts",
116 "mac_rx_lt_1518b_pkts",
117 "mac_rx_gt_1518b_pkts",
118 "mac_rx_length_error",
119 "mac_rx_length_small",
120 "mac_rx_length_large",
121 "mac_rx_jabber",
122 "mac_rx_dropped",
123 "mac_crc_error",
124 "mac_align_error",
125 "eswitch_frames",
126 "eswitch_bytes",
127 "eswitch_multicast_frames",
128 "eswitch_broadcast_frames",
129 "eswitch_unicast_frames",
130 "eswitch_error_free_frames",
131 "eswitch_error_free_bytes",
132 };
133
134 #define QLCNIC_STATS_LEN ARRAY_SIZE(qlcnic_gstrings_stats)
135
136 static const char qlcnic_tx_queue_stats_strings[][ETH_GSTRING_LEN] = {
137 "xmit_on",
138 "xmit_off",
139 "xmit_called",
140 "xmit_finished",
141 "tx_bytes",
142 };
143
144 #define QLCNIC_TX_STATS_LEN ARRAY_SIZE(qlcnic_tx_queue_stats_strings)
145
146 static const char qlcnic_83xx_rx_stats_strings[][ETH_GSTRING_LEN] = {
147 "ctx_rx_bytes",
148 "ctx_rx_pkts",
149 "ctx_lro_pkt_cnt",
150 "ctx_ip_csum_error",
151 "ctx_rx_pkts_wo_ctx",
152 "ctx_rx_pkts_drop_wo_sds_on_card",
153 "ctx_rx_pkts_drop_wo_sds_on_host",
154 "ctx_rx_osized_pkts",
155 "ctx_rx_pkts_dropped_wo_rds",
156 "ctx_rx_unexpected_mcast_pkts",
157 "ctx_invalid_mac_address",
158 "ctx_rx_rds_ring_prim_attempted",
159 "ctx_rx_rds_ring_prim_success",
160 "ctx_num_lro_flows_added",
161 "ctx_num_lro_flows_removed",
162 "ctx_num_lro_flows_active",
163 "ctx_pkts_dropped_unknown",
164 };
165
166 static const char qlcnic_gstrings_test[][ETH_GSTRING_LEN] = {
167 "Register_Test_on_offline",
168 "Link_Test_on_offline",
169 "Interrupt_Test_offline",
170 "Internal_Loopback_offline",
171 "External_Loopback_offline",
172 "EEPROM_Test_offline"
173 };
174
175 #define QLCNIC_TEST_LEN ARRAY_SIZE(qlcnic_gstrings_test)
176
177 static inline int qlcnic_82xx_statistics(struct qlcnic_adapter *adapter)
178 {
179 return ARRAY_SIZE(qlcnic_gstrings_stats) +
180 ARRAY_SIZE(qlcnic_83xx_mac_stats_strings) +
181 QLCNIC_TX_STATS_LEN * adapter->drv_tx_rings;
182 }
183
184 static inline int qlcnic_83xx_statistics(struct qlcnic_adapter *adapter)
185 {
186 return ARRAY_SIZE(qlcnic_gstrings_stats) +
187 ARRAY_SIZE(qlcnic_83xx_tx_stats_strings) +
188 ARRAY_SIZE(qlcnic_83xx_mac_stats_strings) +
189 ARRAY_SIZE(qlcnic_83xx_rx_stats_strings) +
190 QLCNIC_TX_STATS_LEN * adapter->drv_tx_rings;
191 }
192
193 static int qlcnic_dev_statistics_len(struct qlcnic_adapter *adapter)
194 {
195 int len = -1;
196
197 if (qlcnic_82xx_check(adapter)) {
198 len = qlcnic_82xx_statistics(adapter);
199 if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
200 len += ARRAY_SIZE(qlcnic_device_gstrings_stats);
201 } else if (qlcnic_83xx_check(adapter)) {
202 len = qlcnic_83xx_statistics(adapter);
203 }
204
205 return len;
206 }
207
208 #define QLCNIC_TX_INTR_NOT_CONFIGURED 0X78563412
209
210 #define QLCNIC_MAX_EEPROM_LEN 1024
211
212 static const u32 diag_registers[] = {
213 QLCNIC_CMDPEG_STATE,
214 QLCNIC_RCVPEG_STATE,
215 QLCNIC_FW_CAPABILITIES,
216 QLCNIC_CRB_DRV_ACTIVE,
217 QLCNIC_CRB_DEV_STATE,
218 QLCNIC_CRB_DRV_STATE,
219 QLCNIC_CRB_DRV_SCRATCH,
220 QLCNIC_CRB_DEV_PARTITION_INFO,
221 QLCNIC_CRB_DRV_IDC_VER,
222 QLCNIC_PEG_ALIVE_COUNTER,
223 QLCNIC_PEG_HALT_STATUS1,
224 QLCNIC_PEG_HALT_STATUS2,
225 -1
226 };
227
228
229 static const u32 ext_diag_registers[] = {
230 CRB_XG_STATE_P3P,
231 ISR_INT_STATE_REG,
232 QLCNIC_CRB_PEG_NET_0+0x3c,
233 QLCNIC_CRB_PEG_NET_1+0x3c,
234 QLCNIC_CRB_PEG_NET_2+0x3c,
235 QLCNIC_CRB_PEG_NET_4+0x3c,
236 -1
237 };
238
239 #define QLCNIC_MGMT_API_VERSION 3
240 #define QLCNIC_ETHTOOL_REGS_VER 4
241
242 static inline int qlcnic_get_ring_regs_len(struct qlcnic_adapter *adapter)
243 {
244 int ring_regs_cnt = (adapter->drv_tx_rings * 5) +
245 (adapter->max_rds_rings * 2) +
246 (adapter->drv_sds_rings * 3) + 5;
247 return ring_regs_cnt * sizeof(u32);
248 }
249
250 static int qlcnic_get_regs_len(struct net_device *dev)
251 {
252 struct qlcnic_adapter *adapter = netdev_priv(dev);
253 u32 len;
254
255 if (qlcnic_83xx_check(adapter))
256 len = qlcnic_83xx_get_regs_len(adapter);
257 else
258 len = sizeof(ext_diag_registers) + sizeof(diag_registers);
259
260 len += ((QLCNIC_DEV_INFO_SIZE + 2) * sizeof(u32));
261 len += qlcnic_get_ring_regs_len(adapter);
262 return len;
263 }
264
265 static int qlcnic_get_eeprom_len(struct net_device *dev)
266 {
267 return QLCNIC_FLASH_TOTAL_SIZE;
268 }
269
270 static void
271 qlcnic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
272 {
273 struct qlcnic_adapter *adapter = netdev_priv(dev);
274 u32 fw_major, fw_minor, fw_build;
275 fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
276 fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
277 fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
278 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
279 "%d.%d.%d", fw_major, fw_minor, fw_build);
280
281 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
282 sizeof(drvinfo->bus_info));
283 strlcpy(drvinfo->driver, qlcnic_driver_name, sizeof(drvinfo->driver));
284 strlcpy(drvinfo->version, QLCNIC_LINUX_VERSIONID,
285 sizeof(drvinfo->version));
286 }
287
288 static int qlcnic_82xx_get_link_ksettings(struct qlcnic_adapter *adapter,
289 struct ethtool_link_ksettings *ecmd)
290 {
291 struct qlcnic_hardware_context *ahw = adapter->ahw;
292 u32 speed, reg;
293 int check_sfp_module = 0, err = 0;
294 u16 pcifn = ahw->pci_func;
295 u32 supported, advertising;
296
297 /* read which mode */
298 if (adapter->ahw->port_type == QLCNIC_GBE) {
299 supported = (SUPPORTED_10baseT_Half |
300 SUPPORTED_10baseT_Full |
301 SUPPORTED_100baseT_Half |
302 SUPPORTED_100baseT_Full |
303 SUPPORTED_1000baseT_Half |
304 SUPPORTED_1000baseT_Full);
305
306 advertising = (ADVERTISED_100baseT_Half |
307 ADVERTISED_100baseT_Full |
308 ADVERTISED_1000baseT_Half |
309 ADVERTISED_1000baseT_Full);
310
311 ecmd->base.speed = adapter->ahw->link_speed;
312 ecmd->base.duplex = adapter->ahw->link_duplex;
313 ecmd->base.autoneg = adapter->ahw->link_autoneg;
314
315 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
316 u32 val = 0;
317 val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR, &err);
318
319 if (val == QLCNIC_PORT_MODE_802_3_AP) {
320 supported = SUPPORTED_1000baseT_Full;
321 advertising = ADVERTISED_1000baseT_Full;
322 } else {
323 supported = SUPPORTED_10000baseT_Full;
324 advertising = ADVERTISED_10000baseT_Full;
325 }
326
327 if (netif_running(adapter->netdev) && ahw->has_link_events) {
328 if (ahw->linkup) {
329 reg = QLCRD32(adapter,
330 P3P_LINK_SPEED_REG(pcifn), &err);
331 speed = P3P_LINK_SPEED_VAL(pcifn, reg);
332 ahw->link_speed = speed * P3P_LINK_SPEED_MHZ;
333 }
334
335 ecmd->base.speed = ahw->link_speed;
336 ecmd->base.autoneg = ahw->link_autoneg;
337 ecmd->base.duplex = ahw->link_duplex;
338 goto skip;
339 }
340
341 ecmd->base.speed = SPEED_UNKNOWN;
342 ecmd->base.duplex = DUPLEX_UNKNOWN;
343 ecmd->base.autoneg = AUTONEG_DISABLE;
344 } else
345 return -EIO;
346
347 skip:
348 ecmd->base.phy_address = adapter->ahw->physical_port;
349
350 switch (adapter->ahw->board_type) {
351 case QLCNIC_BRDTYPE_P3P_REF_QG:
352 case QLCNIC_BRDTYPE_P3P_4_GB:
353 case QLCNIC_BRDTYPE_P3P_4_GB_MM:
354 supported |= SUPPORTED_Autoneg;
355 advertising |= ADVERTISED_Autoneg;
356 /* fall through */
357 case QLCNIC_BRDTYPE_P3P_10G_CX4:
358 case QLCNIC_BRDTYPE_P3P_10G_CX4_LP:
359 case QLCNIC_BRDTYPE_P3P_10000_BASE_T:
360 supported |= SUPPORTED_TP;
361 advertising |= ADVERTISED_TP;
362 ecmd->base.port = PORT_TP;
363 ecmd->base.autoneg = adapter->ahw->link_autoneg;
364 break;
365 case QLCNIC_BRDTYPE_P3P_IMEZ:
366 case QLCNIC_BRDTYPE_P3P_XG_LOM:
367 case QLCNIC_BRDTYPE_P3P_HMEZ:
368 supported |= SUPPORTED_MII;
369 advertising |= ADVERTISED_MII;
370 ecmd->base.port = PORT_MII;
371 ecmd->base.autoneg = AUTONEG_DISABLE;
372 break;
373 case QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS:
374 case QLCNIC_BRDTYPE_P3P_10G_SFP_CT:
375 case QLCNIC_BRDTYPE_P3P_10G_SFP_QT:
376 advertising |= ADVERTISED_TP;
377 supported |= SUPPORTED_TP;
378 check_sfp_module = netif_running(adapter->netdev) &&
379 ahw->has_link_events;
380 /* fall through */
381 case QLCNIC_BRDTYPE_P3P_10G_XFP:
382 supported |= SUPPORTED_FIBRE;
383 advertising |= ADVERTISED_FIBRE;
384 ecmd->base.port = PORT_FIBRE;
385 ecmd->base.autoneg = AUTONEG_DISABLE;
386 break;
387 case QLCNIC_BRDTYPE_P3P_10G_TP:
388 if (adapter->ahw->port_type == QLCNIC_XGBE) {
389 ecmd->base.autoneg = AUTONEG_DISABLE;
390 supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
391 advertising |=
392 (ADVERTISED_FIBRE | ADVERTISED_TP);
393 ecmd->base.port = PORT_FIBRE;
394 check_sfp_module = netif_running(adapter->netdev) &&
395 ahw->has_link_events;
396 } else {
397 ecmd->base.autoneg = AUTONEG_ENABLE;
398 supported |= (SUPPORTED_TP | SUPPORTED_Autoneg);
399 advertising |=
400 (ADVERTISED_TP | ADVERTISED_Autoneg);
401 ecmd->base.port = PORT_TP;
402 }
403 break;
404 default:
405 dev_err(&adapter->pdev->dev, "Unsupported board model %d\n",
406 adapter->ahw->board_type);
407 return -EIO;
408 }
409
410 if (check_sfp_module) {
411 switch (adapter->ahw->module_type) {
412 case LINKEVENT_MODULE_OPTICAL_UNKNOWN:
413 case LINKEVENT_MODULE_OPTICAL_SRLR:
414 case LINKEVENT_MODULE_OPTICAL_LRM:
415 case LINKEVENT_MODULE_OPTICAL_SFP_1G:
416 ecmd->base.port = PORT_FIBRE;
417 break;
418 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE:
419 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN:
420 case LINKEVENT_MODULE_TWINAX:
421 ecmd->base.port = PORT_TP;
422 break;
423 default:
424 ecmd->base.port = PORT_OTHER;
425 }
426 }
427
428 ethtool_convert_legacy_u32_to_link_mode(ecmd->link_modes.supported,
429 supported);
430 ethtool_convert_legacy_u32_to_link_mode(ecmd->link_modes.advertising,
431 advertising);
432
433 return 0;
434 }
435
436 static int qlcnic_get_link_ksettings(struct net_device *dev,
437 struct ethtool_link_ksettings *ecmd)
438 {
439 struct qlcnic_adapter *adapter = netdev_priv(dev);
440
441 if (qlcnic_82xx_check(adapter))
442 return qlcnic_82xx_get_link_ksettings(adapter, ecmd);
443 else if (qlcnic_83xx_check(adapter))
444 return qlcnic_83xx_get_link_ksettings(adapter, ecmd);
445
446 return -EIO;
447 }
448
449
450 static int qlcnic_set_port_config(struct qlcnic_adapter *adapter,
451 const struct ethtool_link_ksettings *ecmd)
452 {
453 u32 ret = 0, config = 0;
454 /* read which mode */
455 if (ecmd->base.duplex)
456 config |= 0x1;
457
458 if (ecmd->base.autoneg)
459 config |= 0x2;
460
461 switch (ecmd->base.speed) {
462 case SPEED_10:
463 config |= (0 << 8);
464 break;
465 case SPEED_100:
466 config |= (1 << 8);
467 break;
468 case SPEED_1000:
469 config |= (10 << 8);
470 break;
471 default:
472 return -EIO;
473 }
474
475 ret = qlcnic_fw_cmd_set_port(adapter, config);
476
477 if (ret == QLCNIC_RCODE_NOT_SUPPORTED)
478 return -EOPNOTSUPP;
479 else if (ret)
480 return -EIO;
481 return ret;
482 }
483
484 static int qlcnic_set_link_ksettings(struct net_device *dev,
485 const struct ethtool_link_ksettings *ecmd)
486 {
487 u32 ret = 0;
488 struct qlcnic_adapter *adapter = netdev_priv(dev);
489
490 if (qlcnic_83xx_check(adapter))
491 qlcnic_83xx_get_port_type(adapter);
492
493 if (adapter->ahw->port_type != QLCNIC_GBE)
494 return -EOPNOTSUPP;
495
496 if (qlcnic_83xx_check(adapter))
497 ret = qlcnic_83xx_set_link_ksettings(adapter, ecmd);
498 else
499 ret = qlcnic_set_port_config(adapter, ecmd);
500
501 if (!ret)
502 return ret;
503
504 adapter->ahw->link_speed = ecmd->base.speed;
505 adapter->ahw->link_duplex = ecmd->base.duplex;
506 adapter->ahw->link_autoneg = ecmd->base.autoneg;
507
508 if (!netif_running(dev))
509 return 0;
510
511 dev->netdev_ops->ndo_stop(dev);
512 return dev->netdev_ops->ndo_open(dev);
513 }
514
515 static int qlcnic_82xx_get_registers(struct qlcnic_adapter *adapter,
516 u32 *regs_buff)
517 {
518 int i, j = 0, err = 0;
519
520 for (i = QLCNIC_DEV_INFO_SIZE + 1; diag_registers[j] != -1; j++, i++)
521 regs_buff[i] = QLC_SHARED_REG_RD32(adapter, diag_registers[j]);
522 j = 0;
523 while (ext_diag_registers[j] != -1)
524 regs_buff[i++] = QLCRD32(adapter, ext_diag_registers[j++],
525 &err);
526 return i;
527 }
528
529 static void
530 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
531 {
532 struct qlcnic_adapter *adapter = netdev_priv(dev);
533 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
534 struct qlcnic_host_sds_ring *sds_ring;
535 struct qlcnic_host_rds_ring *rds_rings;
536 struct qlcnic_host_tx_ring *tx_ring;
537 u32 *regs_buff = p;
538 int ring, i = 0;
539
540 memset(p, 0, qlcnic_get_regs_len(dev));
541
542 regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) |
543 (adapter->ahw->revision_id << 16) | (adapter->pdev)->device;
544
545 regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff));
546 regs_buff[1] = QLCNIC_MGMT_API_VERSION;
547
548 if (adapter->ahw->capabilities & QLC_83XX_ESWITCH_CAPABILITY)
549 regs_buff[2] = adapter->ahw->max_vnic_func;
550
551 if (qlcnic_82xx_check(adapter))
552 i = qlcnic_82xx_get_registers(adapter, regs_buff);
553 else
554 i = qlcnic_83xx_get_registers(adapter, regs_buff);
555
556 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
557 return;
558
559 /* Marker btw regs and TX ring count */
560 regs_buff[i++] = 0xFFEFCDAB;
561
562 regs_buff[i++] = adapter->drv_tx_rings; /* No. of TX ring */
563 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
564 tx_ring = &adapter->tx_ring[ring];
565 regs_buff[i++] = le32_to_cpu(*(tx_ring->hw_consumer));
566 regs_buff[i++] = tx_ring->sw_consumer;
567 regs_buff[i++] = readl(tx_ring->crb_cmd_producer);
568 regs_buff[i++] = tx_ring->producer;
569 if (tx_ring->crb_intr_mask)
570 regs_buff[i++] = readl(tx_ring->crb_intr_mask);
571 else
572 regs_buff[i++] = QLCNIC_TX_INTR_NOT_CONFIGURED;
573 }
574
575 regs_buff[i++] = adapter->max_rds_rings; /* No. of RX ring */
576 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
577 rds_rings = &recv_ctx->rds_rings[ring];
578 regs_buff[i++] = readl(rds_rings->crb_rcv_producer);
579 regs_buff[i++] = rds_rings->producer;
580 }
581
582 regs_buff[i++] = adapter->drv_sds_rings; /* No. of SDS ring */
583 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
584 sds_ring = &(recv_ctx->sds_rings[ring]);
585 regs_buff[i++] = readl(sds_ring->crb_sts_consumer);
586 regs_buff[i++] = sds_ring->consumer;
587 regs_buff[i++] = readl(sds_ring->crb_intr_mask);
588 }
589 }
590
591 static u32 qlcnic_test_link(struct net_device *dev)
592 {
593 struct qlcnic_adapter *adapter = netdev_priv(dev);
594 int err = 0;
595 u32 val;
596
597 if (qlcnic_83xx_check(adapter)) {
598 val = qlcnic_83xx_test_link(adapter);
599 return (val & 1) ? 0 : 1;
600 }
601 val = QLCRD32(adapter, CRB_XG_STATE_P3P, &err);
602 if (err == -EIO)
603 return err;
604 val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val);
605 return (val == XG_LINK_UP_P3P) ? 0 : 1;
606 }
607
608 static int
609 qlcnic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
610 u8 *bytes)
611 {
612 struct qlcnic_adapter *adapter = netdev_priv(dev);
613 int offset;
614 int ret = -1;
615
616 if (qlcnic_83xx_check(adapter))
617 return 0;
618 if (eeprom->len == 0)
619 return -EINVAL;
620
621 eeprom->magic = (adapter->pdev)->vendor |
622 ((adapter->pdev)->device << 16);
623 offset = eeprom->offset;
624
625 if (qlcnic_82xx_check(adapter))
626 ret = qlcnic_rom_fast_read_words(adapter, offset, bytes,
627 eeprom->len);
628 if (ret < 0)
629 return ret;
630
631 return 0;
632 }
633
634 static void
635 qlcnic_get_ringparam(struct net_device *dev,
636 struct ethtool_ringparam *ring)
637 {
638 struct qlcnic_adapter *adapter = netdev_priv(dev);
639
640 ring->rx_pending = adapter->num_rxd;
641 ring->rx_jumbo_pending = adapter->num_jumbo_rxd;
642 ring->tx_pending = adapter->num_txd;
643
644 ring->rx_max_pending = adapter->max_rxd;
645 ring->rx_jumbo_max_pending = adapter->max_jumbo_rxd;
646 ring->tx_max_pending = MAX_CMD_DESCRIPTORS;
647 }
648
649 static u32
650 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name)
651 {
652 u32 num_desc;
653 num_desc = max(val, min);
654 num_desc = min(num_desc, max);
655 num_desc = roundup_pow_of_two(num_desc);
656
657 if (val != num_desc) {
658 printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n",
659 qlcnic_driver_name, r_name, num_desc, val);
660 }
661
662 return num_desc;
663 }
664
665 static int
666 qlcnic_set_ringparam(struct net_device *dev,
667 struct ethtool_ringparam *ring)
668 {
669 struct qlcnic_adapter *adapter = netdev_priv(dev);
670 u16 num_rxd, num_jumbo_rxd, num_txd;
671
672 if (ring->rx_mini_pending)
673 return -EOPNOTSUPP;
674
675 num_rxd = qlcnic_validate_ringparam(ring->rx_pending,
676 MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx");
677
678 num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending,
679 MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd,
680 "rx jumbo");
681
682 num_txd = qlcnic_validate_ringparam(ring->tx_pending,
683 MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx");
684
685 if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd &&
686 num_jumbo_rxd == adapter->num_jumbo_rxd)
687 return 0;
688
689 adapter->num_rxd = num_rxd;
690 adapter->num_jumbo_rxd = num_jumbo_rxd;
691 adapter->num_txd = num_txd;
692
693 return qlcnic_reset_context(adapter);
694 }
695
696 static int qlcnic_validate_ring_count(struct qlcnic_adapter *adapter,
697 u8 rx_ring, u8 tx_ring)
698 {
699 if (rx_ring == 0 || tx_ring == 0)
700 return -EINVAL;
701
702 if (rx_ring != 0) {
703 if (rx_ring > adapter->max_sds_rings) {
704 netdev_err(adapter->netdev,
705 "Invalid ring count, SDS ring count %d should not be greater than max %d driver sds rings.\n",
706 rx_ring, adapter->max_sds_rings);
707 return -EINVAL;
708 }
709 }
710
711 if (tx_ring != 0) {
712 if (tx_ring > adapter->max_tx_rings) {
713 netdev_err(adapter->netdev,
714 "Invalid ring count, Tx ring count %d should not be greater than max %d driver Tx rings.\n",
715 tx_ring, adapter->max_tx_rings);
716 return -EINVAL;
717 }
718 }
719
720 return 0;
721 }
722
723 static void qlcnic_get_channels(struct net_device *dev,
724 struct ethtool_channels *channel)
725 {
726 struct qlcnic_adapter *adapter = netdev_priv(dev);
727
728 channel->max_rx = adapter->max_sds_rings;
729 channel->max_tx = adapter->max_tx_rings;
730 channel->rx_count = adapter->drv_sds_rings;
731 channel->tx_count = adapter->drv_tx_rings;
732 }
733
734 static int qlcnic_set_channels(struct net_device *dev,
735 struct ethtool_channels *channel)
736 {
737 struct qlcnic_adapter *adapter = netdev_priv(dev);
738 int err;
739
740 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
741 netdev_err(dev, "No RSS/TSS support in non MSI-X mode\n");
742 return -EINVAL;
743 }
744
745 if (channel->other_count || channel->combined_count)
746 return -EINVAL;
747
748 err = qlcnic_validate_ring_count(adapter, channel->rx_count,
749 channel->tx_count);
750 if (err)
751 return err;
752
753 if (adapter->drv_sds_rings != channel->rx_count) {
754 err = qlcnic_validate_rings(adapter, channel->rx_count,
755 QLCNIC_RX_QUEUE);
756 if (err) {
757 netdev_err(dev, "Unable to configure %u SDS rings\n",
758 channel->rx_count);
759 return err;
760 }
761 adapter->drv_rss_rings = channel->rx_count;
762 }
763
764 if (adapter->drv_tx_rings != channel->tx_count) {
765 err = qlcnic_validate_rings(adapter, channel->tx_count,
766 QLCNIC_TX_QUEUE);
767 if (err) {
768 netdev_err(dev, "Unable to configure %u Tx rings\n",
769 channel->tx_count);
770 return err;
771 }
772 adapter->drv_tss_rings = channel->tx_count;
773 }
774
775 adapter->flags |= QLCNIC_TSS_RSS;
776
777 err = qlcnic_setup_rings(adapter);
778 netdev_info(dev, "Allocated %d SDS rings and %d Tx rings\n",
779 adapter->drv_sds_rings, adapter->drv_tx_rings);
780
781 return err;
782 }
783
784 static void
785 qlcnic_get_pauseparam(struct net_device *netdev,
786 struct ethtool_pauseparam *pause)
787 {
788 struct qlcnic_adapter *adapter = netdev_priv(netdev);
789 int port = adapter->ahw->physical_port;
790 int err = 0;
791 __u32 val;
792
793 if (qlcnic_83xx_check(adapter)) {
794 qlcnic_83xx_get_pauseparam(adapter, pause);
795 return;
796 }
797 if (adapter->ahw->port_type == QLCNIC_GBE) {
798 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
799 return;
800 /* get flow control settings */
801 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), &err);
802 if (err == -EIO)
803 return;
804 pause->rx_pause = qlcnic_gb_get_rx_flowctl(val);
805 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, &err);
806 if (err == -EIO)
807 return;
808 switch (port) {
809 case 0:
810 pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val));
811 break;
812 case 1:
813 pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val));
814 break;
815 case 2:
816 pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val));
817 break;
818 case 3:
819 default:
820 pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val));
821 break;
822 }
823 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
824 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
825 return;
826 pause->rx_pause = 1;
827 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, &err);
828 if (err == -EIO)
829 return;
830 if (port == 0)
831 pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val));
832 else
833 pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val));
834 } else {
835 dev_err(&netdev->dev, "Unknown board type: %x\n",
836 adapter->ahw->port_type);
837 }
838 }
839
840 static int
841 qlcnic_set_pauseparam(struct net_device *netdev,
842 struct ethtool_pauseparam *pause)
843 {
844 struct qlcnic_adapter *adapter = netdev_priv(netdev);
845 int port = adapter->ahw->physical_port;
846 int err = 0;
847 __u32 val;
848
849 if (qlcnic_83xx_check(adapter))
850 return qlcnic_83xx_set_pauseparam(adapter, pause);
851
852 /* read mode */
853 if (adapter->ahw->port_type == QLCNIC_GBE) {
854 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
855 return -EIO;
856 /* set flow control */
857 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), &err);
858 if (err == -EIO)
859 return err;
860
861 if (pause->rx_pause)
862 qlcnic_gb_rx_flowctl(val);
863 else
864 qlcnic_gb_unset_rx_flowctl(val);
865
866 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port),
867 val);
868 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), val);
869 /* set autoneg */
870 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, &err);
871 if (err == -EIO)
872 return err;
873 switch (port) {
874 case 0:
875 if (pause->tx_pause)
876 qlcnic_gb_unset_gb0_mask(val);
877 else
878 qlcnic_gb_set_gb0_mask(val);
879 break;
880 case 1:
881 if (pause->tx_pause)
882 qlcnic_gb_unset_gb1_mask(val);
883 else
884 qlcnic_gb_set_gb1_mask(val);
885 break;
886 case 2:
887 if (pause->tx_pause)
888 qlcnic_gb_unset_gb2_mask(val);
889 else
890 qlcnic_gb_set_gb2_mask(val);
891 break;
892 case 3:
893 default:
894 if (pause->tx_pause)
895 qlcnic_gb_unset_gb3_mask(val);
896 else
897 qlcnic_gb_set_gb3_mask(val);
898 break;
899 }
900 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val);
901 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
902 if (!pause->rx_pause || pause->autoneg)
903 return -EOPNOTSUPP;
904
905 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
906 return -EIO;
907
908 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, &err);
909 if (err == -EIO)
910 return err;
911 if (port == 0) {
912 if (pause->tx_pause)
913 qlcnic_xg_unset_xg0_mask(val);
914 else
915 qlcnic_xg_set_xg0_mask(val);
916 } else {
917 if (pause->tx_pause)
918 qlcnic_xg_unset_xg1_mask(val);
919 else
920 qlcnic_xg_set_xg1_mask(val);
921 }
922 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val);
923 } else {
924 dev_err(&netdev->dev, "Unknown board type: %x\n",
925 adapter->ahw->port_type);
926 }
927 return 0;
928 }
929
930 static int qlcnic_reg_test(struct net_device *dev)
931 {
932 struct qlcnic_adapter *adapter = netdev_priv(dev);
933 u32 data_read;
934 int err = 0;
935
936 if (qlcnic_83xx_check(adapter))
937 return qlcnic_83xx_reg_test(adapter);
938
939 data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0), &err);
940 if (err == -EIO)
941 return err;
942 if ((data_read & 0xffff) != adapter->pdev->vendor)
943 return 1;
944
945 return 0;
946 }
947
948 static int qlcnic_eeprom_test(struct net_device *dev)
949 {
950 struct qlcnic_adapter *adapter = netdev_priv(dev);
951
952 if (qlcnic_82xx_check(adapter))
953 return 0;
954
955 return qlcnic_83xx_flash_test(adapter);
956 }
957
958 static int qlcnic_get_sset_count(struct net_device *dev, int sset)
959 {
960
961 struct qlcnic_adapter *adapter = netdev_priv(dev);
962 switch (sset) {
963 case ETH_SS_TEST:
964 return QLCNIC_TEST_LEN;
965 case ETH_SS_STATS:
966 return qlcnic_dev_statistics_len(adapter);
967 default:
968 return -EOPNOTSUPP;
969 }
970 }
971
972 static int qlcnic_irq_test(struct net_device *netdev)
973 {
974 struct qlcnic_adapter *adapter = netdev_priv(netdev);
975 struct qlcnic_hardware_context *ahw = adapter->ahw;
976 struct qlcnic_cmd_args cmd;
977 int ret, drv_sds_rings = adapter->drv_sds_rings;
978 int drv_tx_rings = adapter->drv_tx_rings;
979
980 if (qlcnic_83xx_check(adapter))
981 return qlcnic_83xx_interrupt_test(netdev);
982
983 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
984 return -EIO;
985
986 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST);
987 if (ret)
988 goto clear_diag_irq;
989
990 ahw->diag_cnt = 0;
991 ret = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_INTRPT_TEST);
992 if (ret)
993 goto free_diag_res;
994
995 cmd.req.arg[1] = ahw->pci_func;
996 ret = qlcnic_issue_cmd(adapter, &cmd);
997 if (ret)
998 goto done;
999
1000 usleep_range(1000, 12000);
1001 ret = !ahw->diag_cnt;
1002
1003 done:
1004 qlcnic_free_mbx_args(&cmd);
1005
1006 free_diag_res:
1007 qlcnic_diag_free_res(netdev, drv_sds_rings);
1008
1009 clear_diag_irq:
1010 adapter->drv_sds_rings = drv_sds_rings;
1011 adapter->drv_tx_rings = drv_tx_rings;
1012 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1013
1014 return ret;
1015 }
1016
1017 #define QLCNIC_ILB_PKT_SIZE 64
1018 #define QLCNIC_NUM_ILB_PKT 16
1019 #define QLCNIC_ILB_MAX_RCV_LOOP 10
1020 #define QLCNIC_LB_PKT_POLL_DELAY_MSEC 1
1021 #define QLCNIC_LB_PKT_POLL_COUNT 20
1022
1023 static void qlcnic_create_loopback_buff(unsigned char *data, u8 mac[])
1024 {
1025 unsigned char random_data[] = {0xa8, 0x06, 0x45, 0x00};
1026
1027 memset(data, 0x4e, QLCNIC_ILB_PKT_SIZE);
1028
1029 memcpy(data, mac, ETH_ALEN);
1030 memcpy(data + ETH_ALEN, mac, ETH_ALEN);
1031
1032 memcpy(data + 2 * ETH_ALEN, random_data, sizeof(random_data));
1033 }
1034
1035 int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[])
1036 {
1037 unsigned char buff[QLCNIC_ILB_PKT_SIZE];
1038 qlcnic_create_loopback_buff(buff, mac);
1039 return memcmp(data, buff, QLCNIC_ILB_PKT_SIZE);
1040 }
1041
1042 int qlcnic_do_lb_test(struct qlcnic_adapter *adapter, u8 mode)
1043 {
1044 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1045 struct qlcnic_host_sds_ring *sds_ring = &recv_ctx->sds_rings[0];
1046 struct sk_buff *skb;
1047 int i, loop, cnt = 0;
1048
1049 for (i = 0; i < QLCNIC_NUM_ILB_PKT; i++) {
1050 skb = netdev_alloc_skb(adapter->netdev, QLCNIC_ILB_PKT_SIZE);
1051 qlcnic_create_loopback_buff(skb->data, adapter->mac_addr);
1052 skb_put(skb, QLCNIC_ILB_PKT_SIZE);
1053 adapter->ahw->diag_cnt = 0;
1054 qlcnic_xmit_frame(skb, adapter->netdev);
1055 loop = 0;
1056
1057 do {
1058 msleep(QLCNIC_LB_PKT_POLL_DELAY_MSEC);
1059 qlcnic_process_rcv_ring_diag(sds_ring);
1060 if (loop++ > QLCNIC_LB_PKT_POLL_COUNT)
1061 break;
1062 } while (!adapter->ahw->diag_cnt);
1063
1064 dev_kfree_skb_any(skb);
1065
1066 if (!adapter->ahw->diag_cnt)
1067 dev_warn(&adapter->pdev->dev,
1068 "LB Test: packet #%d was not received\n",
1069 i + 1);
1070 else
1071 cnt++;
1072 }
1073 if (cnt != i) {
1074 dev_err(&adapter->pdev->dev,
1075 "LB Test: failed, TX[%d], RX[%d]\n", i, cnt);
1076 if (mode != QLCNIC_ILB_MODE)
1077 dev_warn(&adapter->pdev->dev,
1078 "WARNING: Please check loopback cable\n");
1079 return -1;
1080 }
1081 return 0;
1082 }
1083
1084 static int qlcnic_loopback_test(struct net_device *netdev, u8 mode)
1085 {
1086 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1087 int drv_tx_rings = adapter->drv_tx_rings;
1088 int drv_sds_rings = adapter->drv_sds_rings;
1089 struct qlcnic_host_sds_ring *sds_ring;
1090 struct qlcnic_hardware_context *ahw = adapter->ahw;
1091 int loop = 0;
1092 int ret;
1093
1094 if (qlcnic_83xx_check(adapter))
1095 return qlcnic_83xx_loopback_test(netdev, mode);
1096
1097 if (!(ahw->capabilities & QLCNIC_FW_CAPABILITY_MULTI_LOOPBACK)) {
1098 dev_info(&adapter->pdev->dev,
1099 "Firmware do not support loopback test\n");
1100 return -EOPNOTSUPP;
1101 }
1102
1103 dev_warn(&adapter->pdev->dev, "%s loopback test in progress\n",
1104 mode == QLCNIC_ILB_MODE ? "internal" : "external");
1105 if (ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
1106 dev_warn(&adapter->pdev->dev,
1107 "Loopback test not supported in nonprivileged mode\n");
1108 return 0;
1109 }
1110
1111 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1112 return -EBUSY;
1113
1114 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_LOOPBACK_TEST);
1115 if (ret)
1116 goto clear_it;
1117
1118 sds_ring = &adapter->recv_ctx->sds_rings[0];
1119 ret = qlcnic_set_lb_mode(adapter, mode);
1120 if (ret)
1121 goto free_res;
1122
1123 ahw->diag_cnt = 0;
1124 do {
1125 msleep(500);
1126 qlcnic_process_rcv_ring_diag(sds_ring);
1127 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) {
1128 netdev_info(netdev,
1129 "Firmware didn't sent link up event to loopback request\n");
1130 ret = -ETIMEDOUT;
1131 goto free_res;
1132 } else if (adapter->ahw->diag_cnt) {
1133 ret = adapter->ahw->diag_cnt;
1134 goto free_res;
1135 }
1136 } while (!QLCNIC_IS_LB_CONFIGURED(ahw->loopback_state));
1137
1138 ret = qlcnic_do_lb_test(adapter, mode);
1139
1140 qlcnic_clear_lb_mode(adapter, mode);
1141
1142 free_res:
1143 qlcnic_diag_free_res(netdev, drv_sds_rings);
1144
1145 clear_it:
1146 adapter->drv_sds_rings = drv_sds_rings;
1147 adapter->drv_tx_rings = drv_tx_rings;
1148 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1149 return ret;
1150 }
1151
1152 static void
1153 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
1154 u64 *data)
1155 {
1156 memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN);
1157
1158 data[0] = qlcnic_reg_test(dev);
1159 if (data[0])
1160 eth_test->flags |= ETH_TEST_FL_FAILED;
1161
1162 data[1] = (u64) qlcnic_test_link(dev);
1163 if (data[1])
1164 eth_test->flags |= ETH_TEST_FL_FAILED;
1165
1166 if (eth_test->flags & ETH_TEST_FL_OFFLINE) {
1167 data[2] = qlcnic_irq_test(dev);
1168 if (data[2])
1169 eth_test->flags |= ETH_TEST_FL_FAILED;
1170
1171 data[3] = qlcnic_loopback_test(dev, QLCNIC_ILB_MODE);
1172 if (data[3])
1173 eth_test->flags |= ETH_TEST_FL_FAILED;
1174
1175 if (eth_test->flags & ETH_TEST_FL_EXTERNAL_LB) {
1176 data[4] = qlcnic_loopback_test(dev, QLCNIC_ELB_MODE);
1177 if (data[4])
1178 eth_test->flags |= ETH_TEST_FL_FAILED;
1179 eth_test->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE;
1180 }
1181
1182 data[5] = qlcnic_eeprom_test(dev);
1183 if (data[5])
1184 eth_test->flags |= ETH_TEST_FL_FAILED;
1185 }
1186 }
1187
1188 static void
1189 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 *data)
1190 {
1191 struct qlcnic_adapter *adapter = netdev_priv(dev);
1192 int index, i, num_stats;
1193
1194 switch (stringset) {
1195 case ETH_SS_TEST:
1196 memcpy(data, *qlcnic_gstrings_test,
1197 QLCNIC_TEST_LEN * ETH_GSTRING_LEN);
1198 break;
1199 case ETH_SS_STATS:
1200 num_stats = ARRAY_SIZE(qlcnic_tx_queue_stats_strings);
1201 for (i = 0; i < adapter->drv_tx_rings; i++) {
1202 for (index = 0; index < num_stats; index++) {
1203 sprintf(data, "tx_queue_%d %s", i,
1204 qlcnic_tx_queue_stats_strings[index]);
1205 data += ETH_GSTRING_LEN;
1206 }
1207 }
1208
1209 for (index = 0; index < QLCNIC_STATS_LEN; index++) {
1210 memcpy(data + index * ETH_GSTRING_LEN,
1211 qlcnic_gstrings_stats[index].stat_string,
1212 ETH_GSTRING_LEN);
1213 }
1214
1215 if (qlcnic_83xx_check(adapter)) {
1216 num_stats = ARRAY_SIZE(qlcnic_83xx_tx_stats_strings);
1217 for (i = 0; i < num_stats; i++, index++)
1218 memcpy(data + index * ETH_GSTRING_LEN,
1219 qlcnic_83xx_tx_stats_strings[i],
1220 ETH_GSTRING_LEN);
1221 num_stats = ARRAY_SIZE(qlcnic_83xx_mac_stats_strings);
1222 for (i = 0; i < num_stats; i++, index++)
1223 memcpy(data + index * ETH_GSTRING_LEN,
1224 qlcnic_83xx_mac_stats_strings[i],
1225 ETH_GSTRING_LEN);
1226 num_stats = ARRAY_SIZE(qlcnic_83xx_rx_stats_strings);
1227 for (i = 0; i < num_stats; i++, index++)
1228 memcpy(data + index * ETH_GSTRING_LEN,
1229 qlcnic_83xx_rx_stats_strings[i],
1230 ETH_GSTRING_LEN);
1231 return;
1232 } else {
1233 num_stats = ARRAY_SIZE(qlcnic_83xx_mac_stats_strings);
1234 for (i = 0; i < num_stats; i++, index++)
1235 memcpy(data + index * ETH_GSTRING_LEN,
1236 qlcnic_83xx_mac_stats_strings[i],
1237 ETH_GSTRING_LEN);
1238 }
1239 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1240 return;
1241 num_stats = ARRAY_SIZE(qlcnic_device_gstrings_stats);
1242 for (i = 0; i < num_stats; index++, i++) {
1243 memcpy(data + index * ETH_GSTRING_LEN,
1244 qlcnic_device_gstrings_stats[i],
1245 ETH_GSTRING_LEN);
1246 }
1247 }
1248 }
1249
1250 static u64 *qlcnic_fill_stats(u64 *data, void *stats, int type)
1251 {
1252 if (type == QLCNIC_MAC_STATS) {
1253 struct qlcnic_mac_statistics *mac_stats =
1254 (struct qlcnic_mac_statistics *)stats;
1255 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_frames);
1256 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bytes);
1257 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_mcast_pkts);
1258 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bcast_pkts);
1259 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_pause_cnt);
1260 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_ctrl_pkt);
1261 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_64b_pkts);
1262 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_127b_pkts);
1263 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_255b_pkts);
1264 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_511b_pkts);
1265 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1023b_pkts);
1266 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1518b_pkts);
1267 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_gt_1518b_pkts);
1268 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_frames);
1269 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bytes);
1270 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_mcast_pkts);
1271 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bcast_pkts);
1272 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_pause_cnt);
1273 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_ctrl_pkt);
1274 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_64b_pkts);
1275 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_127b_pkts);
1276 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_255b_pkts);
1277 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_511b_pkts);
1278 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1023b_pkts);
1279 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1518b_pkts);
1280 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_gt_1518b_pkts);
1281 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_error);
1282 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_small);
1283 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_large);
1284 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_jabber);
1285 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_dropped);
1286 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_crc_error);
1287 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_align_error);
1288 } else if (type == QLCNIC_ESW_STATS) {
1289 struct __qlcnic_esw_statistics *esw_stats =
1290 (struct __qlcnic_esw_statistics *)stats;
1291 *data++ = QLCNIC_FILL_STATS(esw_stats->unicast_frames);
1292 *data++ = QLCNIC_FILL_STATS(esw_stats->multicast_frames);
1293 *data++ = QLCNIC_FILL_STATS(esw_stats->broadcast_frames);
1294 *data++ = QLCNIC_FILL_STATS(esw_stats->dropped_frames);
1295 *data++ = QLCNIC_FILL_STATS(esw_stats->errors);
1296 *data++ = QLCNIC_FILL_STATS(esw_stats->local_frames);
1297 *data++ = QLCNIC_FILL_STATS(esw_stats->numbytes);
1298 }
1299 return data;
1300 }
1301
1302 void qlcnic_update_stats(struct qlcnic_adapter *adapter)
1303 {
1304 struct qlcnic_tx_queue_stats tx_stats;
1305 struct qlcnic_host_tx_ring *tx_ring;
1306 int ring;
1307
1308 memset(&tx_stats, 0, sizeof(tx_stats));
1309 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
1310 tx_ring = &adapter->tx_ring[ring];
1311 tx_stats.xmit_on += tx_ring->tx_stats.xmit_on;
1312 tx_stats.xmit_off += tx_ring->tx_stats.xmit_off;
1313 tx_stats.xmit_called += tx_ring->tx_stats.xmit_called;
1314 tx_stats.xmit_finished += tx_ring->tx_stats.xmit_finished;
1315 tx_stats.tx_bytes += tx_ring->tx_stats.tx_bytes;
1316 }
1317
1318 adapter->stats.xmit_on = tx_stats.xmit_on;
1319 adapter->stats.xmit_off = tx_stats.xmit_off;
1320 adapter->stats.xmitcalled = tx_stats.xmit_called;
1321 adapter->stats.xmitfinished = tx_stats.xmit_finished;
1322 adapter->stats.txbytes = tx_stats.tx_bytes;
1323 }
1324
1325 static u64 *qlcnic_fill_tx_queue_stats(u64 *data, void *stats)
1326 {
1327 struct qlcnic_host_tx_ring *tx_ring;
1328
1329 tx_ring = (struct qlcnic_host_tx_ring *)stats;
1330
1331 *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_on);
1332 *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_off);
1333 *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_called);
1334 *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_finished);
1335 *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.tx_bytes);
1336
1337 return data;
1338 }
1339
1340 static void qlcnic_get_ethtool_stats(struct net_device *dev,
1341 struct ethtool_stats *stats, u64 *data)
1342 {
1343 struct qlcnic_adapter *adapter = netdev_priv(dev);
1344 struct qlcnic_host_tx_ring *tx_ring;
1345 struct qlcnic_esw_statistics port_stats;
1346 struct qlcnic_mac_statistics mac_stats;
1347 int index, ret, length, size, ring;
1348 char *p;
1349
1350 memset(data, 0, stats->n_stats * sizeof(u64));
1351
1352 for (ring = 0, index = 0; ring < adapter->drv_tx_rings; ring++) {
1353 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1354 tx_ring = &adapter->tx_ring[ring];
1355 data = qlcnic_fill_tx_queue_stats(data, tx_ring);
1356 qlcnic_update_stats(adapter);
1357 } else {
1358 data += QLCNIC_TX_STATS_LEN;
1359 }
1360 }
1361
1362 length = QLCNIC_STATS_LEN;
1363 for (index = 0; index < length; index++) {
1364 p = (char *)adapter + qlcnic_gstrings_stats[index].stat_offset;
1365 size = qlcnic_gstrings_stats[index].sizeof_stat;
1366 *data++ = (size == sizeof(u64)) ? (*(u64 *)p) : ((*(u32 *)p));
1367 }
1368
1369 if (qlcnic_83xx_check(adapter)) {
1370 if (adapter->ahw->linkup)
1371 qlcnic_83xx_get_stats(adapter, data);
1372 return;
1373 } else {
1374 /* Retrieve MAC statistics from firmware */
1375 memset(&mac_stats, 0, sizeof(struct qlcnic_mac_statistics));
1376 qlcnic_get_mac_stats(adapter, &mac_stats);
1377 data = qlcnic_fill_stats(data, &mac_stats, QLCNIC_MAC_STATS);
1378 }
1379
1380 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1381 return;
1382
1383 memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics));
1384 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1385 QLCNIC_QUERY_RX_COUNTER, &port_stats.rx);
1386 if (ret)
1387 return;
1388
1389 data = qlcnic_fill_stats(data, &port_stats.rx, QLCNIC_ESW_STATS);
1390 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1391 QLCNIC_QUERY_TX_COUNTER, &port_stats.tx);
1392 if (ret)
1393 return;
1394
1395 qlcnic_fill_stats(data, &port_stats.tx, QLCNIC_ESW_STATS);
1396 }
1397
1398 static int qlcnic_set_led(struct net_device *dev,
1399 enum ethtool_phys_id_state state)
1400 {
1401 struct qlcnic_adapter *adapter = netdev_priv(dev);
1402 int drv_sds_rings = adapter->drv_sds_rings;
1403 int err = -EIO, active = 1;
1404
1405 if (qlcnic_83xx_check(adapter))
1406 return qlcnic_83xx_set_led(dev, state);
1407
1408 if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
1409 netdev_warn(dev, "LED test not supported for non "
1410 "privilege function\n");
1411 return -EOPNOTSUPP;
1412 }
1413
1414 switch (state) {
1415 case ETHTOOL_ID_ACTIVE:
1416 if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state))
1417 return -EBUSY;
1418
1419 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1420 break;
1421
1422 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1423 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1424 break;
1425 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1426 }
1427
1428 if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0) {
1429 err = 0;
1430 break;
1431 }
1432
1433 dev_err(&adapter->pdev->dev,
1434 "Failed to set LED blink state.\n");
1435 break;
1436
1437 case ETHTOOL_ID_INACTIVE:
1438 active = 0;
1439
1440 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1441 break;
1442
1443 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1444 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1445 break;
1446 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1447 }
1448
1449 if (adapter->nic_ops->config_led(adapter, 0, 0xf))
1450 dev_err(&adapter->pdev->dev,
1451 "Failed to reset LED blink state.\n");
1452
1453 break;
1454
1455 default:
1456 return -EINVAL;
1457 }
1458
1459 if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
1460 qlcnic_diag_free_res(dev, drv_sds_rings);
1461
1462 if (!active || err)
1463 clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
1464
1465 return err;
1466 }
1467
1468 static void
1469 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1470 {
1471 struct qlcnic_adapter *adapter = netdev_priv(dev);
1472 u32 wol_cfg;
1473 int err = 0;
1474
1475 if (qlcnic_83xx_check(adapter))
1476 return;
1477 wol->supported = 0;
1478 wol->wolopts = 0;
1479
1480 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV, &err);
1481 if (err == -EIO)
1482 return;
1483 if (wol_cfg & (1UL << adapter->portnum))
1484 wol->supported |= WAKE_MAGIC;
1485
1486 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG, &err);
1487 if (wol_cfg & (1UL << adapter->portnum))
1488 wol->wolopts |= WAKE_MAGIC;
1489 }
1490
1491 static int
1492 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1493 {
1494 struct qlcnic_adapter *adapter = netdev_priv(dev);
1495 u32 wol_cfg;
1496 int err = 0;
1497
1498 if (qlcnic_83xx_check(adapter))
1499 return -EOPNOTSUPP;
1500 if (wol->wolopts & ~WAKE_MAGIC)
1501 return -EINVAL;
1502
1503 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV, &err);
1504 if (err == -EIO)
1505 return err;
1506 if (!(wol_cfg & (1 << adapter->portnum)))
1507 return -EOPNOTSUPP;
1508
1509 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG, &err);
1510 if (err == -EIO)
1511 return err;
1512 if (wol->wolopts & WAKE_MAGIC)
1513 wol_cfg |= 1UL << adapter->portnum;
1514 else
1515 wol_cfg &= ~(1UL << adapter->portnum);
1516
1517 QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg);
1518
1519 return 0;
1520 }
1521
1522 /*
1523 * Set the coalescing parameters. Currently only normal is supported.
1524 * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the
1525 * firmware coalescing to default.
1526 */
1527 static int qlcnic_set_intr_coalesce(struct net_device *netdev,
1528 struct ethtool_coalesce *ethcoal)
1529 {
1530 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1531 int err;
1532
1533 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
1534 return -EINVAL;
1535
1536 /*
1537 * Return Error if unsupported values or
1538 * unsupported parameters are set.
1539 */
1540 if (ethcoal->rx_coalesce_usecs > 0xffff ||
1541 ethcoal->rx_max_coalesced_frames > 0xffff ||
1542 ethcoal->tx_coalesce_usecs > 0xffff ||
1543 ethcoal->tx_max_coalesced_frames > 0xffff ||
1544 ethcoal->rx_coalesce_usecs_irq ||
1545 ethcoal->rx_max_coalesced_frames_irq ||
1546 ethcoal->tx_coalesce_usecs_irq ||
1547 ethcoal->tx_max_coalesced_frames_irq ||
1548 ethcoal->stats_block_coalesce_usecs ||
1549 ethcoal->use_adaptive_rx_coalesce ||
1550 ethcoal->use_adaptive_tx_coalesce ||
1551 ethcoal->pkt_rate_low ||
1552 ethcoal->rx_coalesce_usecs_low ||
1553 ethcoal->rx_max_coalesced_frames_low ||
1554 ethcoal->tx_coalesce_usecs_low ||
1555 ethcoal->tx_max_coalesced_frames_low ||
1556 ethcoal->pkt_rate_high ||
1557 ethcoal->rx_coalesce_usecs_high ||
1558 ethcoal->rx_max_coalesced_frames_high ||
1559 ethcoal->tx_coalesce_usecs_high ||
1560 ethcoal->tx_max_coalesced_frames_high)
1561 return -EINVAL;
1562
1563 err = qlcnic_config_intr_coalesce(adapter, ethcoal);
1564
1565 return err;
1566 }
1567
1568 static int qlcnic_get_intr_coalesce(struct net_device *netdev,
1569 struct ethtool_coalesce *ethcoal)
1570 {
1571 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1572
1573 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1574 return -EINVAL;
1575
1576 ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us;
1577 ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets;
1578 ethcoal->tx_coalesce_usecs = adapter->ahw->coal.tx_time_us;
1579 ethcoal->tx_max_coalesced_frames = adapter->ahw->coal.tx_packets;
1580
1581 return 0;
1582 }
1583
1584 static u32 qlcnic_get_msglevel(struct net_device *netdev)
1585 {
1586 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1587
1588 return adapter->ahw->msg_enable;
1589 }
1590
1591 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl)
1592 {
1593 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1594
1595 adapter->ahw->msg_enable = msglvl;
1596 }
1597
1598 int qlcnic_enable_fw_dump_state(struct qlcnic_adapter *adapter)
1599 {
1600 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1601 u32 val;
1602
1603 if (qlcnic_84xx_check(adapter)) {
1604 if (qlcnic_83xx_lock_driver(adapter))
1605 return -EBUSY;
1606
1607 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1608 val &= ~QLC_83XX_IDC_DISABLE_FW_DUMP;
1609 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
1610
1611 qlcnic_83xx_unlock_driver(adapter);
1612 } else {
1613 fw_dump->enable = true;
1614 }
1615
1616 dev_info(&adapter->pdev->dev, "FW dump enabled\n");
1617
1618 return 0;
1619 }
1620
1621 static int qlcnic_disable_fw_dump_state(struct qlcnic_adapter *adapter)
1622 {
1623 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1624 u32 val;
1625
1626 if (qlcnic_84xx_check(adapter)) {
1627 if (qlcnic_83xx_lock_driver(adapter))
1628 return -EBUSY;
1629
1630 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1631 val |= QLC_83XX_IDC_DISABLE_FW_DUMP;
1632 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
1633
1634 qlcnic_83xx_unlock_driver(adapter);
1635 } else {
1636 fw_dump->enable = false;
1637 }
1638
1639 dev_info(&adapter->pdev->dev, "FW dump disabled\n");
1640
1641 return 0;
1642 }
1643
1644 bool qlcnic_check_fw_dump_state(struct qlcnic_adapter *adapter)
1645 {
1646 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1647 bool state;
1648 u32 val;
1649
1650 if (qlcnic_84xx_check(adapter)) {
1651 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1652 state = (val & QLC_83XX_IDC_DISABLE_FW_DUMP) ? false : true;
1653 } else {
1654 state = fw_dump->enable;
1655 }
1656
1657 return state;
1658 }
1659
1660 static int
1661 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
1662 {
1663 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1664 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1665
1666 if (!fw_dump->tmpl_hdr) {
1667 netdev_err(adapter->netdev, "FW Dump not supported\n");
1668 return -ENOTSUPP;
1669 }
1670
1671 if (fw_dump->clr)
1672 dump->len = fw_dump->tmpl_hdr_size + fw_dump->size;
1673 else
1674 dump->len = 0;
1675
1676 if (!qlcnic_check_fw_dump_state(adapter))
1677 dump->flag = ETH_FW_DUMP_DISABLE;
1678 else
1679 dump->flag = fw_dump->cap_mask;
1680
1681 dump->version = adapter->fw_version;
1682 return 0;
1683 }
1684
1685 static int
1686 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
1687 void *buffer)
1688 {
1689 int i, copy_sz;
1690 u32 *hdr_ptr;
1691 __le32 *data;
1692 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1693 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1694
1695 if (!fw_dump->tmpl_hdr) {
1696 netdev_err(netdev, "FW Dump not supported\n");
1697 return -ENOTSUPP;
1698 }
1699
1700 if (!fw_dump->clr) {
1701 netdev_info(netdev, "Dump not available\n");
1702 return -EINVAL;
1703 }
1704
1705 /* Copy template header first */
1706 copy_sz = fw_dump->tmpl_hdr_size;
1707 hdr_ptr = (u32 *)fw_dump->tmpl_hdr;
1708 data = buffer;
1709 for (i = 0; i < copy_sz/sizeof(u32); i++)
1710 *data++ = cpu_to_le32(*hdr_ptr++);
1711
1712 /* Copy captured dump data */
1713 memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size);
1714 dump->len = copy_sz + fw_dump->size;
1715 dump->flag = fw_dump->cap_mask;
1716
1717 /* Free dump area once data has been captured */
1718 vfree(fw_dump->data);
1719 fw_dump->data = NULL;
1720 fw_dump->clr = 0;
1721 netdev_info(netdev, "extracted the FW dump Successfully\n");
1722 return 0;
1723 }
1724
1725 static int qlcnic_set_dump_mask(struct qlcnic_adapter *adapter, u32 mask)
1726 {
1727 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1728 struct net_device *netdev = adapter->netdev;
1729
1730 if (!qlcnic_check_fw_dump_state(adapter)) {
1731 netdev_info(netdev,
1732 "Can not change driver mask to 0x%x. FW dump not enabled\n",
1733 mask);
1734 return -EOPNOTSUPP;
1735 }
1736
1737 fw_dump->cap_mask = mask;
1738
1739 /* Store new capture mask in template header as well*/
1740 qlcnic_store_cap_mask(adapter, fw_dump->tmpl_hdr, mask);
1741
1742 netdev_info(netdev, "Driver mask changed to: 0x%x\n", mask);
1743 return 0;
1744 }
1745
1746 static int
1747 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val)
1748 {
1749 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1750 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1751 bool valid_mask = false;
1752 int i, ret = 0;
1753
1754 switch (val->flag) {
1755 case QLCNIC_FORCE_FW_DUMP_KEY:
1756 if (!fw_dump->tmpl_hdr) {
1757 netdev_err(netdev, "FW dump not supported\n");
1758 ret = -EOPNOTSUPP;
1759 break;
1760 }
1761
1762 if (!qlcnic_check_fw_dump_state(adapter)) {
1763 netdev_info(netdev, "FW dump not enabled\n");
1764 ret = -EOPNOTSUPP;
1765 break;
1766 }
1767
1768 if (fw_dump->clr) {
1769 netdev_info(netdev,
1770 "Previous dump not cleared, not forcing dump\n");
1771 break;
1772 }
1773
1774 netdev_info(netdev, "Forcing a FW dump\n");
1775 qlcnic_dev_request_reset(adapter, val->flag);
1776 break;
1777 case QLCNIC_DISABLE_FW_DUMP:
1778 if (!fw_dump->tmpl_hdr) {
1779 netdev_err(netdev, "FW dump not supported\n");
1780 ret = -EOPNOTSUPP;
1781 break;
1782 }
1783
1784 ret = qlcnic_disable_fw_dump_state(adapter);
1785 break;
1786
1787 case QLCNIC_ENABLE_FW_DUMP:
1788 if (!fw_dump->tmpl_hdr) {
1789 netdev_err(netdev, "FW dump not supported\n");
1790 ret = -EOPNOTSUPP;
1791 break;
1792 }
1793
1794 ret = qlcnic_enable_fw_dump_state(adapter);
1795 break;
1796
1797 case QLCNIC_FORCE_FW_RESET:
1798 netdev_info(netdev, "Forcing a FW reset\n");
1799 qlcnic_dev_request_reset(adapter, val->flag);
1800 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
1801 break;
1802
1803 case QLCNIC_SET_QUIESCENT:
1804 case QLCNIC_RESET_QUIESCENT:
1805 if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state))
1806 netdev_info(netdev, "Device is in non-operational state\n");
1807 break;
1808
1809 default:
1810 if (!fw_dump->tmpl_hdr) {
1811 netdev_err(netdev, "FW dump not supported\n");
1812 ret = -EOPNOTSUPP;
1813 break;
1814 }
1815
1816 for (i = 0; i < ARRAY_SIZE(qlcnic_fw_dump_level); i++) {
1817 if (val->flag == qlcnic_fw_dump_level[i]) {
1818 valid_mask = true;
1819 break;
1820 }
1821 }
1822
1823 if (valid_mask) {
1824 ret = qlcnic_set_dump_mask(adapter, val->flag);
1825 } else {
1826 netdev_info(netdev, "Invalid dump level: 0x%x\n",
1827 val->flag);
1828 ret = -EINVAL;
1829 }
1830 }
1831 return ret;
1832 }
1833
1834 const struct ethtool_ops qlcnic_ethtool_ops = {
1835 .get_drvinfo = qlcnic_get_drvinfo,
1836 .get_regs_len = qlcnic_get_regs_len,
1837 .get_regs = qlcnic_get_regs,
1838 .get_link = ethtool_op_get_link,
1839 .get_eeprom_len = qlcnic_get_eeprom_len,
1840 .get_eeprom = qlcnic_get_eeprom,
1841 .get_ringparam = qlcnic_get_ringparam,
1842 .set_ringparam = qlcnic_set_ringparam,
1843 .get_channels = qlcnic_get_channels,
1844 .set_channels = qlcnic_set_channels,
1845 .get_pauseparam = qlcnic_get_pauseparam,
1846 .set_pauseparam = qlcnic_set_pauseparam,
1847 .get_wol = qlcnic_get_wol,
1848 .set_wol = qlcnic_set_wol,
1849 .self_test = qlcnic_diag_test,
1850 .get_strings = qlcnic_get_strings,
1851 .get_ethtool_stats = qlcnic_get_ethtool_stats,
1852 .get_sset_count = qlcnic_get_sset_count,
1853 .get_coalesce = qlcnic_get_intr_coalesce,
1854 .set_coalesce = qlcnic_set_intr_coalesce,
1855 .set_phys_id = qlcnic_set_led,
1856 .set_msglevel = qlcnic_set_msglevel,
1857 .get_msglevel = qlcnic_get_msglevel,
1858 .get_dump_flag = qlcnic_get_dump_flag,
1859 .get_dump_data = qlcnic_get_dump_data,
1860 .set_dump = qlcnic_set_dump,
1861 .get_link_ksettings = qlcnic_get_link_ksettings,
1862 .set_link_ksettings = qlcnic_set_link_ksettings,
1863 };
1864
1865 const struct ethtool_ops qlcnic_sriov_vf_ethtool_ops = {
1866 .get_drvinfo = qlcnic_get_drvinfo,
1867 .get_regs_len = qlcnic_get_regs_len,
1868 .get_regs = qlcnic_get_regs,
1869 .get_link = ethtool_op_get_link,
1870 .get_eeprom_len = qlcnic_get_eeprom_len,
1871 .get_eeprom = qlcnic_get_eeprom,
1872 .get_ringparam = qlcnic_get_ringparam,
1873 .set_ringparam = qlcnic_set_ringparam,
1874 .get_channels = qlcnic_get_channels,
1875 .get_pauseparam = qlcnic_get_pauseparam,
1876 .get_wol = qlcnic_get_wol,
1877 .get_strings = qlcnic_get_strings,
1878 .get_ethtool_stats = qlcnic_get_ethtool_stats,
1879 .get_sset_count = qlcnic_get_sset_count,
1880 .get_coalesce = qlcnic_get_intr_coalesce,
1881 .set_coalesce = qlcnic_set_intr_coalesce,
1882 .set_msglevel = qlcnic_set_msglevel,
1883 .get_msglevel = qlcnic_get_msglevel,
1884 .get_link_ksettings = qlcnic_get_link_ksettings,
1885 };
1886
1887 const struct ethtool_ops qlcnic_ethtool_failed_ops = {
1888 .get_drvinfo = qlcnic_get_drvinfo,
1889 .set_msglevel = qlcnic_set_msglevel,
1890 .get_msglevel = qlcnic_get_msglevel,
1891 .set_dump = qlcnic_set_dump,
1892 .get_link_ksettings = qlcnic_get_link_ksettings,
1893 };
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git