?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sfc: Don't use enums as a bitmask.
[zen-stable.git] / drivers / net / qlcnic / qlcnic_ethtool.c
blob9efc690a289f0951740bfd489526f263f38056d5
1 /*
2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2010 QLogic Corporation
4 *
5 * See LICENSE.qlcnic for copyright and licensing details.
6 */
7
8 #include <linux/types.h>
9 #include <linux/delay.h>
10 #include <linux/pci.h>
11 #include <linux/io.h>
12 #include <linux/netdevice.h>
13 #include <linux/ethtool.h>
14
15 #include "qlcnic.h"
16
17 struct qlcnic_stats {
18 char stat_string[ETH_GSTRING_LEN];
19 int sizeof_stat;
20 int stat_offset;
21 };
22
23 #define QLC_SIZEOF(m) FIELD_SIZEOF(struct qlcnic_adapter, m)
24 #define QLC_OFF(m) offsetof(struct qlcnic_adapter, m)
25
26 static const struct qlcnic_stats qlcnic_gstrings_stats[] = {
27 {"xmit_called",
28 QLC_SIZEOF(stats.xmitcalled), QLC_OFF(stats.xmitcalled)},
29 {"xmit_finished",
30 QLC_SIZEOF(stats.xmitfinished), QLC_OFF(stats.xmitfinished)},
31 {"rx_dropped",
32 QLC_SIZEOF(stats.rxdropped), QLC_OFF(stats.rxdropped)},
33 {"tx_dropped",
34 QLC_SIZEOF(stats.txdropped), QLC_OFF(stats.txdropped)},
35 {"csummed",
36 QLC_SIZEOF(stats.csummed), QLC_OFF(stats.csummed)},
37 {"rx_pkts",
38 QLC_SIZEOF(stats.rx_pkts), QLC_OFF(stats.rx_pkts)},
39 {"lro_pkts",
40 QLC_SIZEOF(stats.lro_pkts), QLC_OFF(stats.lro_pkts)},
41 {"rx_bytes",
42 QLC_SIZEOF(stats.rxbytes), QLC_OFF(stats.rxbytes)},
43 {"tx_bytes",
44 QLC_SIZEOF(stats.txbytes), QLC_OFF(stats.txbytes)},
45 {"lrobytes",
46 QLC_SIZEOF(stats.lrobytes), QLC_OFF(stats.lrobytes)},
47 {"lso_frames",
48 QLC_SIZEOF(stats.lso_frames), QLC_OFF(stats.lso_frames)},
49 {"xmit_on",
50 QLC_SIZEOF(stats.xmit_on), QLC_OFF(stats.xmit_on)},
51 {"xmit_off",
52 QLC_SIZEOF(stats.xmit_off), QLC_OFF(stats.xmit_off)},
53 {"skb_alloc_failure", QLC_SIZEOF(stats.skb_alloc_failure),
54 QLC_OFF(stats.skb_alloc_failure)},
55 {"null rxbuf",
56 QLC_SIZEOF(stats.null_rxbuf), QLC_OFF(stats.null_rxbuf)},
57 {"rx dma map error", QLC_SIZEOF(stats.rx_dma_map_error),
58 QLC_OFF(stats.rx_dma_map_error)},
59 {"tx dma map error", QLC_SIZEOF(stats.tx_dma_map_error),
60 QLC_OFF(stats.tx_dma_map_error)},
61
62 };
63
64 static const char qlcnic_device_gstrings_stats[][ETH_GSTRING_LEN] = {
65 "rx unicast frames",
66 "rx multicast frames",
67 "rx broadcast frames",
68 "rx dropped frames",
69 "rx errors",
70 "rx local frames",
71 "rx numbytes",
72 "tx unicast frames",
73 "tx multicast frames",
74 "tx broadcast frames",
75 "tx dropped frames",
76 "tx errors",
77 "tx local frames",
78 "tx numbytes",
79 };
80
81 #define QLCNIC_STATS_LEN ARRAY_SIZE(qlcnic_gstrings_stats)
82 #define QLCNIC_DEVICE_STATS_LEN ARRAY_SIZE(qlcnic_device_gstrings_stats)
83
84 static const char qlcnic_gstrings_test[][ETH_GSTRING_LEN] = {
85 "Register_Test_on_offline",
86 "Link_Test_on_offline",
87 "Interrupt_Test_offline"
88 };
89
90 #define QLCNIC_TEST_LEN ARRAY_SIZE(qlcnic_gstrings_test)
91
92 #define QLCNIC_RING_REGS_COUNT 20
93 #define QLCNIC_RING_REGS_LEN (QLCNIC_RING_REGS_COUNT * sizeof(u32))
94 #define QLCNIC_MAX_EEPROM_LEN 1024
95
96 static const u32 diag_registers[] = {
97 CRB_CMDPEG_STATE,
98 CRB_RCVPEG_STATE,
99 CRB_XG_STATE_P3P,
100 CRB_FW_CAPABILITIES_1,
101 ISR_INT_STATE_REG,
102 QLCNIC_CRB_DRV_ACTIVE,
103 QLCNIC_CRB_DEV_STATE,
104 QLCNIC_CRB_DRV_STATE,
105 QLCNIC_CRB_DRV_SCRATCH,
106 QLCNIC_CRB_DEV_PARTITION_INFO,
107 QLCNIC_CRB_DRV_IDC_VER,
108 QLCNIC_PEG_ALIVE_COUNTER,
109 QLCNIC_PEG_HALT_STATUS1,
110 QLCNIC_PEG_HALT_STATUS2,
111 QLCNIC_CRB_PEG_NET_0+0x3c,
112 QLCNIC_CRB_PEG_NET_1+0x3c,
113 QLCNIC_CRB_PEG_NET_2+0x3c,
114 QLCNIC_CRB_PEG_NET_4+0x3c,
115 -1
116 };
117
118 #define QLCNIC_MGMT_API_VERSION 2
119 #define QLCNIC_DEV_INFO_SIZE 1
120 #define QLCNIC_ETHTOOL_REGS_VER 2
121 static int qlcnic_get_regs_len(struct net_device *dev)
122 {
123 return sizeof(diag_registers) + QLCNIC_RING_REGS_LEN +
124 QLCNIC_DEV_INFO_SIZE + 1;
125 }
126
127 static int qlcnic_get_eeprom_len(struct net_device *dev)
128 {
129 return QLCNIC_FLASH_TOTAL_SIZE;
130 }
131
132 static void
133 qlcnic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
134 {
135 struct qlcnic_adapter *adapter = netdev_priv(dev);
136 u32 fw_major, fw_minor, fw_build;
137
138 fw_major = QLCRD32(adapter, QLCNIC_FW_VERSION_MAJOR);
139 fw_minor = QLCRD32(adapter, QLCNIC_FW_VERSION_MINOR);
140 fw_build = QLCRD32(adapter, QLCNIC_FW_VERSION_SUB);
141 sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
142
143 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
144 strlcpy(drvinfo->driver, qlcnic_driver_name, 32);
145 strlcpy(drvinfo->version, QLCNIC_LINUX_VERSIONID, 32);
146 }
147
148 static int
149 qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
150 {
151 struct qlcnic_adapter *adapter = netdev_priv(dev);
152 int check_sfp_module = 0;
153 u16 pcifn = adapter->ahw->pci_func;
154
155 /* read which mode */
156 if (adapter->ahw->port_type == QLCNIC_GBE) {
157 ecmd->supported = (SUPPORTED_10baseT_Half |
158 SUPPORTED_10baseT_Full |
159 SUPPORTED_100baseT_Half |
160 SUPPORTED_100baseT_Full |
161 SUPPORTED_1000baseT_Half |
162 SUPPORTED_1000baseT_Full);
163
164 ecmd->advertising = (ADVERTISED_100baseT_Half |
165 ADVERTISED_100baseT_Full |
166 ADVERTISED_1000baseT_Half |
167 ADVERTISED_1000baseT_Full);
168
169 ethtool_cmd_speed_set(ecmd, adapter->link_speed);
170 ecmd->duplex = adapter->link_duplex;
171 ecmd->autoneg = adapter->link_autoneg;
172
173 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
174 u32 val;
175
176 val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR);
177 if (val == QLCNIC_PORT_MODE_802_3_AP) {
178 ecmd->supported = SUPPORTED_1000baseT_Full;
179 ecmd->advertising = ADVERTISED_1000baseT_Full;
180 } else {
181 ecmd->supported = SUPPORTED_10000baseT_Full;
182 ecmd->advertising = ADVERTISED_10000baseT_Full;
183 }
184
185 if (netif_running(dev) && adapter->has_link_events) {
186 ethtool_cmd_speed_set(ecmd, adapter->link_speed);
187 ecmd->autoneg = adapter->link_autoneg;
188 ecmd->duplex = adapter->link_duplex;
189 goto skip;
190 }
191
192 val = QLCRD32(adapter, P3P_LINK_SPEED_REG(pcifn));
193 ethtool_cmd_speed_set(ecmd, P3P_LINK_SPEED_MHZ *
194 P3P_LINK_SPEED_VAL(pcifn, val));
195 ecmd->duplex = DUPLEX_FULL;
196 ecmd->autoneg = AUTONEG_DISABLE;
197 } else
198 return -EIO;
199
200 skip:
201 ecmd->phy_address = adapter->physical_port;
202 ecmd->transceiver = XCVR_EXTERNAL;
203
204 switch (adapter->ahw->board_type) {
205 case QLCNIC_BRDTYPE_P3P_REF_QG:
206 case QLCNIC_BRDTYPE_P3P_4_GB:
207 case QLCNIC_BRDTYPE_P3P_4_GB_MM:
208
209 ecmd->supported |= SUPPORTED_Autoneg;
210 ecmd->advertising |= ADVERTISED_Autoneg;
211 case QLCNIC_BRDTYPE_P3P_10G_CX4:
212 case QLCNIC_BRDTYPE_P3P_10G_CX4_LP:
213 case QLCNIC_BRDTYPE_P3P_10000_BASE_T:
214 ecmd->supported |= SUPPORTED_TP;
215 ecmd->advertising |= ADVERTISED_TP;
216 ecmd->port = PORT_TP;
217 ecmd->autoneg = adapter->link_autoneg;
218 break;
219 case QLCNIC_BRDTYPE_P3P_IMEZ:
220 case QLCNIC_BRDTYPE_P3P_XG_LOM:
221 case QLCNIC_BRDTYPE_P3P_HMEZ:
222 ecmd->supported |= SUPPORTED_MII;
223 ecmd->advertising |= ADVERTISED_MII;
224 ecmd->port = PORT_MII;
225 ecmd->autoneg = AUTONEG_DISABLE;
226 break;
227 case QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS:
228 case QLCNIC_BRDTYPE_P3P_10G_SFP_CT:
229 case QLCNIC_BRDTYPE_P3P_10G_SFP_QT:
230 ecmd->advertising |= ADVERTISED_TP;
231 ecmd->supported |= SUPPORTED_TP;
232 check_sfp_module = netif_running(dev) &&
233 adapter->has_link_events;
234 case QLCNIC_BRDTYPE_P3P_10G_XFP:
235 ecmd->supported |= SUPPORTED_FIBRE;
236 ecmd->advertising |= ADVERTISED_FIBRE;
237 ecmd->port = PORT_FIBRE;
238 ecmd->autoneg = AUTONEG_DISABLE;
239 break;
240 case QLCNIC_BRDTYPE_P3P_10G_TP:
241 if (adapter->ahw->port_type == QLCNIC_XGBE) {
242 ecmd->autoneg = AUTONEG_DISABLE;
243 ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
244 ecmd->advertising |=
245 (ADVERTISED_FIBRE | ADVERTISED_TP);
246 ecmd->port = PORT_FIBRE;
247 check_sfp_module = netif_running(dev) &&
248 adapter->has_link_events;
249 } else {
250 ecmd->autoneg = AUTONEG_ENABLE;
251 ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg);
252 ecmd->advertising |=
253 (ADVERTISED_TP | ADVERTISED_Autoneg);
254 ecmd->port = PORT_TP;
255 }
256 break;
257 default:
258 dev_err(&adapter->pdev->dev, "Unsupported board model %d\n",
259 adapter->ahw->board_type);
260 return -EIO;
261 }
262
263 if (check_sfp_module) {
264 switch (adapter->module_type) {
265 case LINKEVENT_MODULE_OPTICAL_UNKNOWN:
266 case LINKEVENT_MODULE_OPTICAL_SRLR:
267 case LINKEVENT_MODULE_OPTICAL_LRM:
268 case LINKEVENT_MODULE_OPTICAL_SFP_1G:
269 ecmd->port = PORT_FIBRE;
270 break;
271 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE:
272 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN:
273 case LINKEVENT_MODULE_TWINAX:
274 ecmd->port = PORT_TP;
275 break;
276 default:
277 ecmd->port = PORT_OTHER;
278 }
279 }
280
281 return 0;
282 }
283
284 static int
285 qlcnic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
286 {
287 u32 config = 0;
288 u32 ret = 0;
289 struct qlcnic_adapter *adapter = netdev_priv(dev);
290
291 if (adapter->ahw->port_type != QLCNIC_GBE)
292 return -EOPNOTSUPP;
293
294 /* read which mode */
295 if (ecmd->duplex)
296 config |= 0x1;
297
298 if (ecmd->autoneg)
299 config |= 0x2;
300
301 switch (ethtool_cmd_speed(ecmd)) {
302 case SPEED_10:
303 config |= (0 << 8);
304 break;
305 case SPEED_100:
306 config |= (1 << 8);
307 break;
308 case SPEED_1000:
309 config |= (10 << 8);
310 break;
311 default:
312 return -EIO;
313 }
314
315 ret = qlcnic_fw_cmd_set_port(adapter, config);
316
317 if (ret == QLCNIC_RCODE_NOT_SUPPORTED)
318 return -EOPNOTSUPP;
319 else if (ret)
320 return -EIO;
321
322 adapter->link_speed = ethtool_cmd_speed(ecmd);
323 adapter->link_duplex = ecmd->duplex;
324 adapter->link_autoneg = ecmd->autoneg;
325
326 if (!netif_running(dev))
327 return 0;
328
329 dev->netdev_ops->ndo_stop(dev);
330 return dev->netdev_ops->ndo_open(dev);
331 }
332
333 static void
334 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
335 {
336 struct qlcnic_adapter *adapter = netdev_priv(dev);
337 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
338 struct qlcnic_host_sds_ring *sds_ring;
339 u32 *regs_buff = p;
340 int ring, i = 0, j = 0;
341
342 memset(p, 0, qlcnic_get_regs_len(dev));
343 regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) |
344 (adapter->ahw->revision_id << 16) | (adapter->pdev)->device;
345
346 regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff));
347 regs_buff[1] = QLCNIC_MGMT_API_VERSION;
348
349 for (i = QLCNIC_DEV_INFO_SIZE + 1; diag_registers[j] != -1; j++, i++)
350 regs_buff[i] = QLCRD32(adapter, diag_registers[j]);
351
352 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
353 return;
354
355 regs_buff[i++] = 0xFFEFCDAB; /* Marker btw regs and ring count*/
356
357 regs_buff[i++] = 1; /* No. of tx ring */
358 regs_buff[i++] = le32_to_cpu(*(adapter->tx_ring->hw_consumer));
359 regs_buff[i++] = readl(adapter->tx_ring->crb_cmd_producer);
360
361 regs_buff[i++] = 2; /* No. of rx ring */
362 regs_buff[i++] = readl(recv_ctx->rds_rings[0].crb_rcv_producer);
363 regs_buff[i++] = readl(recv_ctx->rds_rings[1].crb_rcv_producer);
364
365 regs_buff[i++] = adapter->max_sds_rings;
366
367 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
368 sds_ring = &(recv_ctx->sds_rings[ring]);
369 regs_buff[i++] = readl(sds_ring->crb_sts_consumer);
370 }
371 }
372
373 static u32 qlcnic_test_link(struct net_device *dev)
374 {
375 struct qlcnic_adapter *adapter = netdev_priv(dev);
376 u32 val;
377
378 val = QLCRD32(adapter, CRB_XG_STATE_P3P);
379 val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val);
380 return (val == XG_LINK_UP_P3P) ? 0 : 1;
381 }
382
383 static int
384 qlcnic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
385 u8 *bytes)
386 {
387 struct qlcnic_adapter *adapter = netdev_priv(dev);
388 int offset;
389 int ret;
390
391 if (eeprom->len == 0)
392 return -EINVAL;
393
394 eeprom->magic = (adapter->pdev)->vendor |
395 ((adapter->pdev)->device << 16);
396 offset = eeprom->offset;
397
398 ret = qlcnic_rom_fast_read_words(adapter, offset, bytes,
399 eeprom->len);
400 if (ret < 0)
401 return ret;
402
403 return 0;
404 }
405
406 static void
407 qlcnic_get_ringparam(struct net_device *dev,
408 struct ethtool_ringparam *ring)
409 {
410 struct qlcnic_adapter *adapter = netdev_priv(dev);
411
412 ring->rx_pending = adapter->num_rxd;
413 ring->rx_jumbo_pending = adapter->num_jumbo_rxd;
414 ring->tx_pending = adapter->num_txd;
415
416 ring->rx_max_pending = adapter->max_rxd;
417 ring->rx_jumbo_max_pending = adapter->max_jumbo_rxd;
418 ring->tx_max_pending = MAX_CMD_DESCRIPTORS;
419
420 ring->rx_mini_max_pending = 0;
421 ring->rx_mini_pending = 0;
422 }
423
424 static u32
425 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name)
426 {
427 u32 num_desc;
428 num_desc = max(val, min);
429 num_desc = min(num_desc, max);
430 num_desc = roundup_pow_of_two(num_desc);
431
432 if (val != num_desc) {
433 printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n",
434 qlcnic_driver_name, r_name, num_desc, val);
435 }
436
437 return num_desc;
438 }
439
440 static int
441 qlcnic_set_ringparam(struct net_device *dev,
442 struct ethtool_ringparam *ring)
443 {
444 struct qlcnic_adapter *adapter = netdev_priv(dev);
445 u16 num_rxd, num_jumbo_rxd, num_txd;
446
447 if (ring->rx_mini_pending)
448 return -EOPNOTSUPP;
449
450 num_rxd = qlcnic_validate_ringparam(ring->rx_pending,
451 MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx");
452
453 num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending,
454 MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd,
455 "rx jumbo");
456
457 num_txd = qlcnic_validate_ringparam(ring->tx_pending,
458 MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx");
459
460 if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd &&
461 num_jumbo_rxd == adapter->num_jumbo_rxd)
462 return 0;
463
464 adapter->num_rxd = num_rxd;
465 adapter->num_jumbo_rxd = num_jumbo_rxd;
466 adapter->num_txd = num_txd;
467
468 return qlcnic_reset_context(adapter);
469 }
470
471 static void qlcnic_get_channels(struct net_device *dev,
472 struct ethtool_channels *channel)
473 {
474 struct qlcnic_adapter *adapter = netdev_priv(dev);
475
476 channel->max_rx = rounddown_pow_of_two(min_t(int,
477 adapter->max_rx_ques, num_online_cpus()));
478 channel->max_tx = adapter->max_tx_ques;
479
480 channel->rx_count = adapter->max_sds_rings;
481 channel->tx_count = adapter->max_tx_ques;
482 }
483
484 static int qlcnic_set_channels(struct net_device *dev,
485 struct ethtool_channels *channel)
486 {
487 struct qlcnic_adapter *adapter = netdev_priv(dev);
488 int err;
489
490 if (channel->other_count || channel->combined_count ||
491 channel->tx_count != channel->max_tx)
492 return -EINVAL;
493
494 err = qlcnic_validate_max_rss(dev, channel->max_rx, channel->rx_count);
495 if (err)
496 return err;
497
498 err = qlcnic_set_max_rss(adapter, channel->rx_count);
499 netdev_info(dev, "allocated 0x%x sds rings\n",
500 adapter->max_sds_rings);
501 return err;
502 }
503
504 static void
505 qlcnic_get_pauseparam(struct net_device *netdev,
506 struct ethtool_pauseparam *pause)
507 {
508 struct qlcnic_adapter *adapter = netdev_priv(netdev);
509 int port = adapter->physical_port;
510 __u32 val;
511
512 if (adapter->ahw->port_type == QLCNIC_GBE) {
513 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
514 return;
515 /* get flow control settings */
516 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
517 pause->rx_pause = qlcnic_gb_get_rx_flowctl(val);
518 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
519 switch (port) {
520 case 0:
521 pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val));
522 break;
523 case 1:
524 pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val));
525 break;
526 case 2:
527 pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val));
528 break;
529 case 3:
530 default:
531 pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val));
532 break;
533 }
534 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
535 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
536 return;
537 pause->rx_pause = 1;
538 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
539 if (port == 0)
540 pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val));
541 else
542 pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val));
543 } else {
544 dev_err(&netdev->dev, "Unknown board type: %x\n",
545 adapter->ahw->port_type);
546 }
547 }
548
549 static int
550 qlcnic_set_pauseparam(struct net_device *netdev,
551 struct ethtool_pauseparam *pause)
552 {
553 struct qlcnic_adapter *adapter = netdev_priv(netdev);
554 int port = adapter->physical_port;
555 __u32 val;
556
557 /* read mode */
558 if (adapter->ahw->port_type == QLCNIC_GBE) {
559 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
560 return -EIO;
561 /* set flow control */
562 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
563
564 if (pause->rx_pause)
565 qlcnic_gb_rx_flowctl(val);
566 else
567 qlcnic_gb_unset_rx_flowctl(val);
568
569 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port),
570 val);
571 /* set autoneg */
572 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
573 switch (port) {
574 case 0:
575 if (pause->tx_pause)
576 qlcnic_gb_unset_gb0_mask(val);
577 else
578 qlcnic_gb_set_gb0_mask(val);
579 break;
580 case 1:
581 if (pause->tx_pause)
582 qlcnic_gb_unset_gb1_mask(val);
583 else
584 qlcnic_gb_set_gb1_mask(val);
585 break;
586 case 2:
587 if (pause->tx_pause)
588 qlcnic_gb_unset_gb2_mask(val);
589 else
590 qlcnic_gb_set_gb2_mask(val);
591 break;
592 case 3:
593 default:
594 if (pause->tx_pause)
595 qlcnic_gb_unset_gb3_mask(val);
596 else
597 qlcnic_gb_set_gb3_mask(val);
598 break;
599 }
600 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val);
601 } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
602 if (!pause->rx_pause || pause->autoneg)
603 return -EOPNOTSUPP;
604
605 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
606 return -EIO;
607
608 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
609 if (port == 0) {
610 if (pause->tx_pause)
611 qlcnic_xg_unset_xg0_mask(val);
612 else
613 qlcnic_xg_set_xg0_mask(val);
614 } else {
615 if (pause->tx_pause)
616 qlcnic_xg_unset_xg1_mask(val);
617 else
618 qlcnic_xg_set_xg1_mask(val);
619 }
620 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val);
621 } else {
622 dev_err(&netdev->dev, "Unknown board type: %x\n",
623 adapter->ahw->port_type);
624 }
625 return 0;
626 }
627
628 static int qlcnic_reg_test(struct net_device *dev)
629 {
630 struct qlcnic_adapter *adapter = netdev_priv(dev);
631 u32 data_read;
632
633 data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0));
634 if ((data_read & 0xffff) != adapter->pdev->vendor)
635 return 1;
636
637 return 0;
638 }
639
640 static int qlcnic_get_sset_count(struct net_device *dev, int sset)
641 {
642 struct qlcnic_adapter *adapter = netdev_priv(dev);
643 switch (sset) {
644 case ETH_SS_TEST:
645 return QLCNIC_TEST_LEN;
646 case ETH_SS_STATS:
647 if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
648 return QLCNIC_STATS_LEN + QLCNIC_DEVICE_STATS_LEN;
649 return QLCNIC_STATS_LEN;
650 default:
651 return -EOPNOTSUPP;
652 }
653 }
654
655 static int qlcnic_irq_test(struct net_device *netdev)
656 {
657 struct qlcnic_adapter *adapter = netdev_priv(netdev);
658 int max_sds_rings = adapter->max_sds_rings;
659 int ret;
660
661 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
662 return -EIO;
663
664 ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST);
665 if (ret)
666 goto clear_it;
667
668 adapter->diag_cnt = 0;
669 ret = qlcnic_issue_cmd(adapter, adapter->ahw->pci_func,
670 adapter->fw_hal_version, adapter->ahw->pci_func,
671 0, 0, 0x00000011);
672 if (ret)
673 goto done;
674
675 msleep(10);
676
677 ret = !adapter->diag_cnt;
678
679 done:
680 qlcnic_diag_free_res(netdev, max_sds_rings);
681
682 clear_it:
683 adapter->max_sds_rings = max_sds_rings;
684 clear_bit(__QLCNIC_RESETTING, &adapter->state);
685 return ret;
686 }
687
688 static void
689 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
690 u64 *data)
691 {
692 memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN);
693
694 data[0] = qlcnic_reg_test(dev);
695 if (data[0])
696 eth_test->flags |= ETH_TEST_FL_FAILED;
697
698 data[1] = (u64) qlcnic_test_link(dev);
699 if (data[1])
700 eth_test->flags |= ETH_TEST_FL_FAILED;
701
702 if (eth_test->flags & ETH_TEST_FL_OFFLINE) {
703 data[2] = qlcnic_irq_test(dev);
704 if (data[2])
705 eth_test->flags |= ETH_TEST_FL_FAILED;
706
707
708 }
709 }
710
711 static void
712 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
713 {
714 struct qlcnic_adapter *adapter = netdev_priv(dev);
715 int index, i;
716
717 switch (stringset) {
718 case ETH_SS_TEST:
719 memcpy(data, *qlcnic_gstrings_test,
720 QLCNIC_TEST_LEN * ETH_GSTRING_LEN);
721 break;
722 case ETH_SS_STATS:
723 for (index = 0; index < QLCNIC_STATS_LEN; index++) {
724 memcpy(data + index * ETH_GSTRING_LEN,
725 qlcnic_gstrings_stats[index].stat_string,
726 ETH_GSTRING_LEN);
727 }
728 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
729 return;
730 for (i = 0; i < QLCNIC_DEVICE_STATS_LEN; index++, i++) {
731 memcpy(data + index * ETH_GSTRING_LEN,
732 qlcnic_device_gstrings_stats[i],
733 ETH_GSTRING_LEN);
734 }
735 }
736 }
737
738 #define QLCNIC_FILL_ESWITCH_STATS(VAL1) \
739 (((VAL1) == QLCNIC_ESW_STATS_NOT_AVAIL) ? 0 : VAL1)
740
741 static void
742 qlcnic_fill_device_stats(int *index, u64 *data,
743 struct __qlcnic_esw_statistics *stats)
744 {
745 int ind = *index;
746
747 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->unicast_frames);
748 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->multicast_frames);
749 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->broadcast_frames);
750 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->dropped_frames);
751 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->errors);
752 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->local_frames);
753 data[ind++] = QLCNIC_FILL_ESWITCH_STATS(stats->numbytes);
754
755 *index = ind;
756 }
757
758 static void
759 qlcnic_get_ethtool_stats(struct net_device *dev,
760 struct ethtool_stats *stats, u64 * data)
761 {
762 struct qlcnic_adapter *adapter = netdev_priv(dev);
763 struct qlcnic_esw_statistics port_stats;
764 int index, ret;
765
766 for (index = 0; index < QLCNIC_STATS_LEN; index++) {
767 char *p =
768 (char *)adapter +
769 qlcnic_gstrings_stats[index].stat_offset;
770 data[index] =
771 (qlcnic_gstrings_stats[index].sizeof_stat ==
772 sizeof(u64)) ? *(u64 *)p:(*(u32 *)p);
773 }
774
775 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
776 return;
777
778 memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics));
779 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
780 QLCNIC_QUERY_RX_COUNTER, &port_stats.rx);
781 if (ret)
782 return;
783
784 qlcnic_fill_device_stats(&index, data, &port_stats.rx);
785
786 ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
787 QLCNIC_QUERY_TX_COUNTER, &port_stats.tx);
788 if (ret)
789 return;
790
791 qlcnic_fill_device_stats(&index, data, &port_stats.tx);
792 }
793
794 static int qlcnic_set_led(struct net_device *dev,
795 enum ethtool_phys_id_state state)
796 {
797 struct qlcnic_adapter *adapter = netdev_priv(dev);
798 int max_sds_rings = adapter->max_sds_rings;
799
800 switch (state) {
801 case ETHTOOL_ID_ACTIVE:
802 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
803 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
804 return -EIO;
805
806 if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST)) {
807 clear_bit(__QLCNIC_RESETTING, &adapter->state);
808 return -EIO;
809 }
810 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
811 }
812
813 if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0)
814 return 0;
815
816 dev_err(&adapter->pdev->dev,
817 "Failed to set LED blink state.\n");
818 break;
819
820 case ETHTOOL_ID_INACTIVE:
821 if (adapter->nic_ops->config_led(adapter, 0, 0xf))
822 dev_err(&adapter->pdev->dev,
823 "Failed to reset LED blink state.\n");
824
825 break;
826
827 default:
828 return -EINVAL;
829 }
830
831 if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state)) {
832 qlcnic_diag_free_res(dev, max_sds_rings);
833 clear_bit(__QLCNIC_RESETTING, &adapter->state);
834 }
835
836 return -EIO;
837 }
838
839 static void
840 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
841 {
842 struct qlcnic_adapter *adapter = netdev_priv(dev);
843 u32 wol_cfg;
844
845 wol->supported = 0;
846 wol->wolopts = 0;
847
848 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
849 if (wol_cfg & (1UL << adapter->portnum))
850 wol->supported |= WAKE_MAGIC;
851
852 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
853 if (wol_cfg & (1UL << adapter->portnum))
854 wol->wolopts |= WAKE_MAGIC;
855 }
856
857 static int
858 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
859 {
860 struct qlcnic_adapter *adapter = netdev_priv(dev);
861 u32 wol_cfg;
862
863 if (wol->wolopts & ~WAKE_MAGIC)
864 return -EOPNOTSUPP;
865
866 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
867 if (!(wol_cfg & (1 << adapter->portnum)))
868 return -EOPNOTSUPP;
869
870 wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
871 if (wol->wolopts & WAKE_MAGIC)
872 wol_cfg |= 1UL << adapter->portnum;
873 else
874 wol_cfg &= ~(1UL << adapter->portnum);
875
876 QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg);
877
878 return 0;
879 }
880
881 /*
882 * Set the coalescing parameters. Currently only normal is supported.
883 * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the
884 * firmware coalescing to default.
885 */
886 static int qlcnic_set_intr_coalesce(struct net_device *netdev,
887 struct ethtool_coalesce *ethcoal)
888 {
889 struct qlcnic_adapter *adapter = netdev_priv(netdev);
890
891 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
892 return -EINVAL;
893
894 /*
895 * Return Error if unsupported values or
896 * unsupported parameters are set.
897 */
898 if (ethcoal->rx_coalesce_usecs > 0xffff ||
899 ethcoal->rx_max_coalesced_frames > 0xffff ||
900 ethcoal->tx_coalesce_usecs ||
901 ethcoal->tx_max_coalesced_frames ||
902 ethcoal->rx_coalesce_usecs_irq ||
903 ethcoal->rx_max_coalesced_frames_irq ||
904 ethcoal->tx_coalesce_usecs_irq ||
905 ethcoal->tx_max_coalesced_frames_irq ||
906 ethcoal->stats_block_coalesce_usecs ||
907 ethcoal->use_adaptive_rx_coalesce ||
908 ethcoal->use_adaptive_tx_coalesce ||
909 ethcoal->pkt_rate_low ||
910 ethcoal->rx_coalesce_usecs_low ||
911 ethcoal->rx_max_coalesced_frames_low ||
912 ethcoal->tx_coalesce_usecs_low ||
913 ethcoal->tx_max_coalesced_frames_low ||
914 ethcoal->pkt_rate_high ||
915 ethcoal->rx_coalesce_usecs_high ||
916 ethcoal->rx_max_coalesced_frames_high ||
917 ethcoal->tx_coalesce_usecs_high ||
918 ethcoal->tx_max_coalesced_frames_high)
919 return -EINVAL;
920
921 if (!ethcoal->rx_coalesce_usecs ||
922 !ethcoal->rx_max_coalesced_frames) {
923 adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
924 adapter->ahw->coal.rx_time_us =
925 QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
926 adapter->ahw->coal.rx_packets =
927 QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
928 } else {
929 adapter->ahw->coal.flag = 0;
930 adapter->ahw->coal.rx_time_us = ethcoal->rx_coalesce_usecs;
931 adapter->ahw->coal.rx_packets =
932 ethcoal->rx_max_coalesced_frames;
933 }
934
935 qlcnic_config_intr_coalesce(adapter);
936
937 return 0;
938 }
939
940 static int qlcnic_get_intr_coalesce(struct net_device *netdev,
941 struct ethtool_coalesce *ethcoal)
942 {
943 struct qlcnic_adapter *adapter = netdev_priv(netdev);
944
945 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
946 return -EINVAL;
947
948 ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us;
949 ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets;
950
951 return 0;
952 }
953
954 static u32 qlcnic_get_msglevel(struct net_device *netdev)
955 {
956 struct qlcnic_adapter *adapter = netdev_priv(netdev);
957
958 return adapter->msg_enable;
959 }
960
961 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl)
962 {
963 struct qlcnic_adapter *adapter = netdev_priv(netdev);
964
965 adapter->msg_enable = msglvl;
966 }
967
968 static int
969 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
970 {
971 struct qlcnic_adapter *adapter = netdev_priv(netdev);
972 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
973
974 dump->len = fw_dump->tmpl_hdr->size + fw_dump->size;
975 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
976 dump->version = adapter->fw_version;
977 return 0;
978 }
979
980 static int
981 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
982 void *buffer)
983 {
984 int i, copy_sz;
985 u32 *hdr_ptr, *data;
986 struct qlcnic_adapter *adapter = netdev_priv(netdev);
987 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
988
989 if (qlcnic_api_lock(adapter))
990 return -EIO;
991 if (!fw_dump->clr) {
992 netdev_info(netdev, "Dump not available\n");
993 qlcnic_api_unlock(adapter);
994 return -EINVAL;
995 }
996 /* Copy template header first */
997 copy_sz = fw_dump->tmpl_hdr->size;
998 hdr_ptr = (u32 *) fw_dump->tmpl_hdr;
999 data = (u32 *) buffer;
1000 for (i = 0; i < copy_sz/sizeof(u32); i++)
1001 *data++ = cpu_to_le32(*hdr_ptr++);
1002
1003 /* Copy captured dump data */
1004 memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size);
1005 dump->len = copy_sz + fw_dump->size;
1006 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
1007
1008 /* Free dump area once data has been captured */
1009 vfree(fw_dump->data);
1010 fw_dump->data = NULL;
1011 fw_dump->clr = 0;
1012 qlcnic_api_unlock(adapter);
1013
1014 return 0;
1015 }
1016
1017 static int
1018 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val)
1019 {
1020 int ret = 0;
1021 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1022 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1023
1024 if (val->flag == QLCNIC_FORCE_FW_DUMP_KEY) {
1025 netdev_info(netdev, "Forcing a FW dump\n");
1026 qlcnic_dev_request_reset(adapter);
1027 } else {
1028 if (val->flag > QLCNIC_DUMP_MASK_MAX ||
1029 val->flag < QLCNIC_DUMP_MASK_MIN) {
1030 netdev_info(netdev,
1031 "Invalid dump level: 0x%x\n", val->flag);
1032 ret = -EINVAL;
1033 goto out;
1034 }
1035 if (qlcnic_api_lock(adapter))
1036 return -EIO;
1037 fw_dump->tmpl_hdr->drv_cap_mask = val->flag & 0xff;
1038 qlcnic_api_unlock(adapter);
1039 netdev_info(netdev, "Driver mask changed to: 0x%x\n",
1040 fw_dump->tmpl_hdr->drv_cap_mask);
1041 }
1042 out:
1043 return ret;
1044 }
1045
1046 const struct ethtool_ops qlcnic_ethtool_ops = {
1047 .get_settings = qlcnic_get_settings,
1048 .set_settings = qlcnic_set_settings,
1049 .get_drvinfo = qlcnic_get_drvinfo,
1050 .get_regs_len = qlcnic_get_regs_len,
1051 .get_regs = qlcnic_get_regs,
1052 .get_link = ethtool_op_get_link,
1053 .get_eeprom_len = qlcnic_get_eeprom_len,
1054 .get_eeprom = qlcnic_get_eeprom,
1055 .get_ringparam = qlcnic_get_ringparam,
1056 .set_ringparam = qlcnic_set_ringparam,
1057 .get_channels = qlcnic_get_channels,
1058 .set_channels = qlcnic_set_channels,
1059 .get_pauseparam = qlcnic_get_pauseparam,
1060 .set_pauseparam = qlcnic_set_pauseparam,
1061 .get_wol = qlcnic_get_wol,
1062 .set_wol = qlcnic_set_wol,
1063 .self_test = qlcnic_diag_test,
1064 .get_strings = qlcnic_get_strings,
1065 .get_ethtool_stats = qlcnic_get_ethtool_stats,
1066 .get_sset_count = qlcnic_get_sset_count,
1067 .get_coalesce = qlcnic_get_intr_coalesce,
1068 .set_coalesce = qlcnic_set_intr_coalesce,
1069 .set_phys_id = qlcnic_set_led,
1070 .set_msglevel = qlcnic_set_msglevel,
1071 .get_msglevel = qlcnic_get_msglevel,
1072 .get_dump_flag = qlcnic_get_dump_flag,
1073 .get_dump_data = qlcnic_get_dump_data,
1074 .set_dump = qlcnic_set_dump,
1075 };