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