1 /*
2 * Copyright (C) 2013-2015 Chelsio Communications. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * The full GNU General Public License is included in this distribution in
14 * the file called "COPYING".
15 *
16 */
17
18 #include <linux/firmware.h>
19 #include <linux/mdio.h>
20
21 #include "cxgb4.h"
22 #include "t4_regs.h"
23 #include "t4fw_api.h"
24
25 #define EEPROM_MAGIC 0x38E2F10C
26
get_msglevel(struct net_device * dev)27 static u32 get_msglevel(struct net_device *dev)
28 {
29 return netdev2adap(dev)->msg_enable;
30 }
31
set_msglevel(struct net_device * dev,u32 val)32 static void set_msglevel(struct net_device *dev, u32 val)
33 {
34 netdev2adap(dev)->msg_enable = val;
35 }
36
37 static const char stats_strings[][ETH_GSTRING_LEN] = {
38 "TxOctetsOK ",
39 "TxFramesOK ",
40 "TxBroadcastFrames ",
41 "TxMulticastFrames ",
42 "TxUnicastFrames ",
43 "TxErrorFrames ",
44
45 "TxFrames64 ",
46 "TxFrames65To127 ",
47 "TxFrames128To255 ",
48 "TxFrames256To511 ",
49 "TxFrames512To1023 ",
50 "TxFrames1024To1518 ",
51 "TxFrames1519ToMax ",
52
53 "TxFramesDropped ",
54 "TxPauseFrames ",
55 "TxPPP0Frames ",
56 "TxPPP1Frames ",
57 "TxPPP2Frames ",
58 "TxPPP3Frames ",
59 "TxPPP4Frames ",
60 "TxPPP5Frames ",
61 "TxPPP6Frames ",
62 "TxPPP7Frames ",
63
64 "RxOctetsOK ",
65 "RxFramesOK ",
66 "RxBroadcastFrames ",
67 "RxMulticastFrames ",
68 "RxUnicastFrames ",
69
70 "RxFramesTooLong ",
71 "RxJabberErrors ",
72 "RxFCSErrors ",
73 "RxLengthErrors ",
74 "RxSymbolErrors ",
75 "RxRuntFrames ",
76
77 "RxFrames64 ",
78 "RxFrames65To127 ",
79 "RxFrames128To255 ",
80 "RxFrames256To511 ",
81 "RxFrames512To1023 ",
82 "RxFrames1024To1518 ",
83 "RxFrames1519ToMax ",
84
85 "RxPauseFrames ",
86 "RxPPP0Frames ",
87 "RxPPP1Frames ",
88 "RxPPP2Frames ",
89 "RxPPP3Frames ",
90 "RxPPP4Frames ",
91 "RxPPP5Frames ",
92 "RxPPP6Frames ",
93 "RxPPP7Frames ",
94
95 "RxBG0FramesDropped ",
96 "RxBG1FramesDropped ",
97 "RxBG2FramesDropped ",
98 "RxBG3FramesDropped ",
99 "RxBG0FramesTrunc ",
100 "RxBG1FramesTrunc ",
101 "RxBG2FramesTrunc ",
102 "RxBG3FramesTrunc ",
103
104 "TSO ",
105 "TxCsumOffload ",
106 "RxCsumGood ",
107 "VLANextractions ",
108 "VLANinsertions ",
109 "GROpackets ",
110 "GROmerged ",
111 "WriteCoalSuccess ",
112 "WriteCoalFail ",
113 };
114
get_sset_count(struct net_device * dev,int sset)115 static int get_sset_count(struct net_device *dev, int sset)
116 {
117 switch (sset) {
118 case ETH_SS_STATS:
119 return ARRAY_SIZE(stats_strings);
120 default:
121 return -EOPNOTSUPP;
122 }
123 }
124
get_regs_len(struct net_device * dev)125 static int get_regs_len(struct net_device *dev)
126 {
127 struct adapter *adap = netdev2adap(dev);
128
129 return t4_get_regs_len(adap);
130 }
131
get_eeprom_len(struct net_device * dev)132 static int get_eeprom_len(struct net_device *dev)
133 {
134 return EEPROMSIZE;
135 }
136
get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)137 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
138 {
139 struct adapter *adapter = netdev2adap(dev);
140 u32 exprom_vers;
141
142 strlcpy(info->driver, cxgb4_driver_name, sizeof(info->driver));
143 strlcpy(info->version, cxgb4_driver_version,
144 sizeof(info->version));
145 strlcpy(info->bus_info, pci_name(adapter->pdev),
146 sizeof(info->bus_info));
147
148 if (adapter->params.fw_vers)
149 snprintf(info->fw_version, sizeof(info->fw_version),
150 "%u.%u.%u.%u, TP %u.%u.%u.%u",
151 FW_HDR_FW_VER_MAJOR_G(adapter->params.fw_vers),
152 FW_HDR_FW_VER_MINOR_G(adapter->params.fw_vers),
153 FW_HDR_FW_VER_MICRO_G(adapter->params.fw_vers),
154 FW_HDR_FW_VER_BUILD_G(adapter->params.fw_vers),
155 FW_HDR_FW_VER_MAJOR_G(adapter->params.tp_vers),
156 FW_HDR_FW_VER_MINOR_G(adapter->params.tp_vers),
157 FW_HDR_FW_VER_MICRO_G(adapter->params.tp_vers),
158 FW_HDR_FW_VER_BUILD_G(adapter->params.tp_vers));
159
160 if (!t4_get_exprom_version(adapter, &exprom_vers))
161 snprintf(info->erom_version, sizeof(info->erom_version),
162 "%u.%u.%u.%u",
163 FW_HDR_FW_VER_MAJOR_G(exprom_vers),
164 FW_HDR_FW_VER_MINOR_G(exprom_vers),
165 FW_HDR_FW_VER_MICRO_G(exprom_vers),
166 FW_HDR_FW_VER_BUILD_G(exprom_vers));
167 }
168
get_strings(struct net_device * dev,u32 stringset,u8 * data)169 static void get_strings(struct net_device *dev, u32 stringset, u8 *data)
170 {
171 if (stringset == ETH_SS_STATS)
172 memcpy(data, stats_strings, sizeof(stats_strings));
173 }
174
175 /* port stats maintained per queue of the port. They should be in the same
176 * order as in stats_strings above.
177 */
178 struct queue_port_stats {
179 u64 tso;
180 u64 tx_csum;
181 u64 rx_csum;
182 u64 vlan_ex;
183 u64 vlan_ins;
184 u64 gro_pkts;
185 u64 gro_merged;
186 };
187
collect_sge_port_stats(const struct adapter * adap,const struct port_info * p,struct queue_port_stats * s)188 static void collect_sge_port_stats(const struct adapter *adap,
189 const struct port_info *p,
190 struct queue_port_stats *s)
191 {
192 int i;
193 const struct sge_eth_txq *tx = &adap->sge.ethtxq[p->first_qset];
194 const struct sge_eth_rxq *rx = &adap->sge.ethrxq[p->first_qset];
195
196 memset(s, 0, sizeof(*s));
197 for (i = 0; i < p->nqsets; i++, rx++, tx++) {
198 s->tso += tx->tso;
199 s->tx_csum += tx->tx_cso;
200 s->rx_csum += rx->stats.rx_cso;
201 s->vlan_ex += rx->stats.vlan_ex;
202 s->vlan_ins += tx->vlan_ins;
203 s->gro_pkts += rx->stats.lro_pkts;
204 s->gro_merged += rx->stats.lro_merged;
205 }
206 }
207
get_stats(struct net_device * dev,struct ethtool_stats * stats,u64 * data)208 static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
209 u64 *data)
210 {
211 struct port_info *pi = netdev_priv(dev);
212 struct adapter *adapter = pi->adapter;
213 u32 val1, val2;
214
215 t4_get_port_stats(adapter, pi->tx_chan, (struct port_stats *)data);
216
217 data += sizeof(struct port_stats) / sizeof(u64);
218 collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
219 data += sizeof(struct queue_port_stats) / sizeof(u64);
220 if (!is_t4(adapter->params.chip)) {
221 t4_write_reg(adapter, SGE_STAT_CFG_A, STATSOURCE_T5_V(7));
222 val1 = t4_read_reg(adapter, SGE_STAT_TOTAL_A);
223 val2 = t4_read_reg(adapter, SGE_STAT_MATCH_A);
224 *data = val1 - val2;
225 data++;
226 *data = val2;
227 data++;
228 } else {
229 memset(data, 0, 2 * sizeof(u64));
230 *data += 2;
231 }
232 }
233
get_regs(struct net_device * dev,struct ethtool_regs * regs,void * buf)234 static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
235 void *buf)
236 {
237 struct adapter *adap = netdev2adap(dev);
238 size_t buf_size;
239
240 buf_size = t4_get_regs_len(adap);
241 regs->version = mk_adap_vers(adap);
242 t4_get_regs(adap, buf, buf_size);
243 }
244
restart_autoneg(struct net_device * dev)245 static int restart_autoneg(struct net_device *dev)
246 {
247 struct port_info *p = netdev_priv(dev);
248
249 if (!netif_running(dev))
250 return -EAGAIN;
251 if (p->link_cfg.autoneg != AUTONEG_ENABLE)
252 return -EINVAL;
253 t4_restart_aneg(p->adapter, p->adapter->fn, p->tx_chan);
254 return 0;
255 }
256
identify_port(struct net_device * dev,enum ethtool_phys_id_state state)257 static int identify_port(struct net_device *dev,
258 enum ethtool_phys_id_state state)
259 {
260 unsigned int val;
261 struct adapter *adap = netdev2adap(dev);
262
263 if (state == ETHTOOL_ID_ACTIVE)
264 val = 0xffff;
265 else if (state == ETHTOOL_ID_INACTIVE)
266 val = 0;
267 else
268 return -EINVAL;
269
270 return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid, val);
271 }
272
from_fw_linkcaps(enum fw_port_type type,unsigned int caps)273 static unsigned int from_fw_linkcaps(enum fw_port_type type, unsigned int caps)
274 {
275 unsigned int v = 0;
276
277 if (type == FW_PORT_TYPE_BT_SGMII || type == FW_PORT_TYPE_BT_XFI ||
278 type == FW_PORT_TYPE_BT_XAUI) {
279 v |= SUPPORTED_TP;
280 if (caps & FW_PORT_CAP_SPEED_100M)
281 v |= SUPPORTED_100baseT_Full;
282 if (caps & FW_PORT_CAP_SPEED_1G)
283 v |= SUPPORTED_1000baseT_Full;
284 if (caps & FW_PORT_CAP_SPEED_10G)
285 v |= SUPPORTED_10000baseT_Full;
286 } else if (type == FW_PORT_TYPE_KX4 || type == FW_PORT_TYPE_KX) {
287 v |= SUPPORTED_Backplane;
288 if (caps & FW_PORT_CAP_SPEED_1G)
289 v |= SUPPORTED_1000baseKX_Full;
290 if (caps & FW_PORT_CAP_SPEED_10G)
291 v |= SUPPORTED_10000baseKX4_Full;
292 } else if (type == FW_PORT_TYPE_KR) {
293 v |= SUPPORTED_Backplane | SUPPORTED_10000baseKR_Full;
294 } else if (type == FW_PORT_TYPE_BP_AP) {
295 v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC |
296 SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full;
297 } else if (type == FW_PORT_TYPE_BP4_AP) {
298 v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC |
299 SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full |
300 SUPPORTED_10000baseKX4_Full;
301 } else if (type == FW_PORT_TYPE_FIBER_XFI ||
302 type == FW_PORT_TYPE_FIBER_XAUI ||
303 type == FW_PORT_TYPE_SFP ||
304 type == FW_PORT_TYPE_QSFP_10G ||
305 type == FW_PORT_TYPE_QSA) {
306 v |= SUPPORTED_FIBRE;
307 if (caps & FW_PORT_CAP_SPEED_1G)
308 v |= SUPPORTED_1000baseT_Full;
309 if (caps & FW_PORT_CAP_SPEED_10G)
310 v |= SUPPORTED_10000baseT_Full;
311 } else if (type == FW_PORT_TYPE_BP40_BA ||
312 type == FW_PORT_TYPE_QSFP) {
313 v |= SUPPORTED_40000baseSR4_Full;
314 v |= SUPPORTED_FIBRE;
315 }
316
317 if (caps & FW_PORT_CAP_ANEG)
318 v |= SUPPORTED_Autoneg;
319 return v;
320 }
321
to_fw_linkcaps(unsigned int caps)322 static unsigned int to_fw_linkcaps(unsigned int caps)
323 {
324 unsigned int v = 0;
325
326 if (caps & ADVERTISED_100baseT_Full)
327 v |= FW_PORT_CAP_SPEED_100M;
328 if (caps & ADVERTISED_1000baseT_Full)
329 v |= FW_PORT_CAP_SPEED_1G;
330 if (caps & ADVERTISED_10000baseT_Full)
331 v |= FW_PORT_CAP_SPEED_10G;
332 if (caps & ADVERTISED_40000baseSR4_Full)
333 v |= FW_PORT_CAP_SPEED_40G;
334 return v;
335 }
336
get_settings(struct net_device * dev,struct ethtool_cmd * cmd)337 static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
338 {
339 const struct port_info *p = netdev_priv(dev);
340
341 if (p->port_type == FW_PORT_TYPE_BT_SGMII ||
342 p->port_type == FW_PORT_TYPE_BT_XFI ||
343 p->port_type == FW_PORT_TYPE_BT_XAUI) {
344 cmd->port = PORT_TP;
345 } else if (p->port_type == FW_PORT_TYPE_FIBER_XFI ||
346 p->port_type == FW_PORT_TYPE_FIBER_XAUI) {
347 cmd->port = PORT_FIBRE;
348 } else if (p->port_type == FW_PORT_TYPE_SFP ||
349 p->port_type == FW_PORT_TYPE_QSFP_10G ||
350 p->port_type == FW_PORT_TYPE_QSA ||
351 p->port_type == FW_PORT_TYPE_QSFP) {
352 if (p->mod_type == FW_PORT_MOD_TYPE_LR ||
353 p->mod_type == FW_PORT_MOD_TYPE_SR ||
354 p->mod_type == FW_PORT_MOD_TYPE_ER ||
355 p->mod_type == FW_PORT_MOD_TYPE_LRM)
356 cmd->port = PORT_FIBRE;
357 else if (p->mod_type == FW_PORT_MOD_TYPE_TWINAX_PASSIVE ||
358 p->mod_type == FW_PORT_MOD_TYPE_TWINAX_ACTIVE)
359 cmd->port = PORT_DA;
360 else
361 cmd->port = PORT_OTHER;
362 } else {
363 cmd->port = PORT_OTHER;
364 }
365
366 if (p->mdio_addr >= 0) {
367 cmd->phy_address = p->mdio_addr;
368 cmd->transceiver = XCVR_EXTERNAL;
369 cmd->mdio_support = p->port_type == FW_PORT_TYPE_BT_SGMII ?
370 MDIO_SUPPORTS_C22 : MDIO_SUPPORTS_C45;
371 } else {
372 cmd->phy_address = 0; /* not really, but no better option */
373 cmd->transceiver = XCVR_INTERNAL;
374 cmd->mdio_support = 0;
375 }
376
377 cmd->supported = from_fw_linkcaps(p->port_type, p->link_cfg.supported);
378 cmd->advertising = from_fw_linkcaps(p->port_type,
379 p->link_cfg.advertising);
380 ethtool_cmd_speed_set(cmd,
381 netif_carrier_ok(dev) ? p->link_cfg.speed : 0);
382 cmd->duplex = DUPLEX_FULL;
383 cmd->autoneg = p->link_cfg.autoneg;
384 cmd->maxtxpkt = 0;
385 cmd->maxrxpkt = 0;
386 return 0;
387 }
388
speed_to_caps(int speed)389 static unsigned int speed_to_caps(int speed)
390 {
391 if (speed == 100)
392 return FW_PORT_CAP_SPEED_100M;
393 if (speed == 1000)
394 return FW_PORT_CAP_SPEED_1G;
395 if (speed == 10000)
396 return FW_PORT_CAP_SPEED_10G;
397 if (speed == 40000)
398 return FW_PORT_CAP_SPEED_40G;
399 return 0;
400 }
401
set_settings(struct net_device * dev,struct ethtool_cmd * cmd)402 static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
403 {
404 unsigned int cap;
405 struct port_info *p = netdev_priv(dev);
406 struct link_config *lc = &p->link_cfg;
407 u32 speed = ethtool_cmd_speed(cmd);
408
409 if (cmd->duplex != DUPLEX_FULL) /* only full-duplex supported */
410 return -EINVAL;
411
412 if (!(lc->supported & FW_PORT_CAP_ANEG)) {
413 /* PHY offers a single speed. See if that's what's
414 * being requested.
415 */
416 if (cmd->autoneg == AUTONEG_DISABLE &&
417 (lc->supported & speed_to_caps(speed)))
418 return 0;
419 return -EINVAL;
420 }
421
422 if (cmd->autoneg == AUTONEG_DISABLE) {
423 cap = speed_to_caps(speed);
424
425 if (!(lc->supported & cap) ||
426 (speed == 1000) ||
427 (speed == 10000) ||
428 (speed == 40000))
429 return -EINVAL;
430 lc->requested_speed = cap;
431 lc->advertising = 0;
432 } else {
433 cap = to_fw_linkcaps(cmd->advertising);
434 if (!(lc->supported & cap))
435 return -EINVAL;
436 lc->requested_speed = 0;
437 lc->advertising = cap | FW_PORT_CAP_ANEG;
438 }
439 lc->autoneg = cmd->autoneg;
440
441 if (netif_running(dev))
442 return t4_link_start(p->adapter, p->adapter->fn, p->tx_chan,
443 lc);
444 return 0;
445 }
446
get_pauseparam(struct net_device * dev,struct ethtool_pauseparam * epause)447 static void get_pauseparam(struct net_device *dev,
448 struct ethtool_pauseparam *epause)
449 {
450 struct port_info *p = netdev_priv(dev);
451
452 epause->autoneg = (p->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
453 epause->rx_pause = (p->link_cfg.fc & PAUSE_RX) != 0;
454 epause->tx_pause = (p->link_cfg.fc & PAUSE_TX) != 0;
455 }
456
set_pauseparam(struct net_device * dev,struct ethtool_pauseparam * epause)457 static int set_pauseparam(struct net_device *dev,
458 struct ethtool_pauseparam *epause)
459 {
460 struct port_info *p = netdev_priv(dev);
461 struct link_config *lc = &p->link_cfg;
462
463 if (epause->autoneg == AUTONEG_DISABLE)
464 lc->requested_fc = 0;
465 else if (lc->supported & FW_PORT_CAP_ANEG)
466 lc->requested_fc = PAUSE_AUTONEG;
467 else
468 return -EINVAL;
469
470 if (epause->rx_pause)
471 lc->requested_fc |= PAUSE_RX;
472 if (epause->tx_pause)
473 lc->requested_fc |= PAUSE_TX;
474 if (netif_running(dev))
475 return t4_link_start(p->adapter, p->adapter->fn, p->tx_chan,
476 lc);
477 return 0;
478 }
479
get_sge_param(struct net_device * dev,struct ethtool_ringparam * e)480 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
481 {
482 const struct port_info *pi = netdev_priv(dev);
483 const struct sge *s = &pi->adapter->sge;
484
485 e->rx_max_pending = MAX_RX_BUFFERS;
486 e->rx_mini_max_pending = MAX_RSPQ_ENTRIES;
487 e->rx_jumbo_max_pending = 0;
488 e->tx_max_pending = MAX_TXQ_ENTRIES;
489
490 e->rx_pending = s->ethrxq[pi->first_qset].fl.size - 8;
491 e->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size;
492 e->rx_jumbo_pending = 0;
493 e->tx_pending = s->ethtxq[pi->first_qset].q.size;
494 }
495
set_sge_param(struct net_device * dev,struct ethtool_ringparam * e)496 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
497 {
498 int i;
499 const struct port_info *pi = netdev_priv(dev);
500 struct adapter *adapter = pi->adapter;
501 struct sge *s = &adapter->sge;
502
503 if (e->rx_pending > MAX_RX_BUFFERS || e->rx_jumbo_pending ||
504 e->tx_pending > MAX_TXQ_ENTRIES ||
505 e->rx_mini_pending > MAX_RSPQ_ENTRIES ||
506 e->rx_mini_pending < MIN_RSPQ_ENTRIES ||
507 e->rx_pending < MIN_FL_ENTRIES || e->tx_pending < MIN_TXQ_ENTRIES)
508 return -EINVAL;
509
510 if (adapter->flags & FULL_INIT_DONE)
511 return -EBUSY;
512
513 for (i = 0; i < pi->nqsets; ++i) {
514 s->ethtxq[pi->first_qset + i].q.size = e->tx_pending;
515 s->ethrxq[pi->first_qset + i].fl.size = e->rx_pending + 8;
516 s->ethrxq[pi->first_qset + i].rspq.size = e->rx_mini_pending;
517 }
518 return 0;
519 }
520
521 /**
522 * set_rx_intr_params - set a net devices's RX interrupt holdoff paramete!
523 * @dev: the network device
524 * @us: the hold-off time in us, or 0 to disable timer
525 * @cnt: the hold-off packet count, or 0 to disable counter
526 *
527 * Set the RX interrupt hold-off parameters for a network device.
528 */
set_rx_intr_params(struct net_device * dev,unsigned int us,unsigned int cnt)529 static int set_rx_intr_params(struct net_device *dev,
530 unsigned int us, unsigned int cnt)
531 {
532 int i, err;
533 struct port_info *pi = netdev_priv(dev);
534 struct adapter *adap = pi->adapter;
535 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
536
537 for (i = 0; i < pi->nqsets; i++, q++) {
538 err = cxgb4_set_rspq_intr_params(&q->rspq, us, cnt);
539 if (err)
540 return err;
541 }
542 return 0;
543 }
544
set_adaptive_rx_setting(struct net_device * dev,int adaptive_rx)545 static int set_adaptive_rx_setting(struct net_device *dev, int adaptive_rx)
546 {
547 int i;
548 struct port_info *pi = netdev_priv(dev);
549 struct adapter *adap = pi->adapter;
550 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
551
552 for (i = 0; i < pi->nqsets; i++, q++)
553 q->rspq.adaptive_rx = adaptive_rx;
554
555 return 0;
556 }
557
get_adaptive_rx_setting(struct net_device * dev)558 static int get_adaptive_rx_setting(struct net_device *dev)
559 {
560 struct port_info *pi = netdev_priv(dev);
561 struct adapter *adap = pi->adapter;
562 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset];
563
564 return q->rspq.adaptive_rx;
565 }
566
set_coalesce(struct net_device * dev,struct ethtool_coalesce * c)567 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
568 {
569 set_adaptive_rx_setting(dev, c->use_adaptive_rx_coalesce);
570 return set_rx_intr_params(dev, c->rx_coalesce_usecs,
571 c->rx_max_coalesced_frames);
572 }
573
get_coalesce(struct net_device * dev,struct ethtool_coalesce * c)574 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
575 {
576 const struct port_info *pi = netdev_priv(dev);
577 const struct adapter *adap = pi->adapter;
578 const struct sge_rspq *rq = &adap->sge.ethrxq[pi->first_qset].rspq;
579
580 c->rx_coalesce_usecs = qtimer_val(adap, rq);
581 c->rx_max_coalesced_frames = (rq->intr_params & QINTR_CNT_EN) ?
582 adap->sge.counter_val[rq->pktcnt_idx] : 0;
583 c->use_adaptive_rx_coalesce = get_adaptive_rx_setting(dev);
584 return 0;
585 }
586
587 /**
588 * eeprom_ptov - translate a physical EEPROM address to virtual
589 * @phys_addr: the physical EEPROM address
590 * @fn: the PCI function number
591 * @sz: size of function-specific area
592 *
593 * Translate a physical EEPROM address to virtual. The first 1K is
594 * accessed through virtual addresses starting at 31K, the rest is
595 * accessed through virtual addresses starting at 0.
596 *
597 * The mapping is as follows:
598 * [0..1K) -> [31K..32K)
599 * [1K..1K+A) -> [31K-A..31K)
600 * [1K+A..ES) -> [0..ES-A-1K)
601 *
602 * where A = @fn * @sz, and ES = EEPROM size.
603 */
eeprom_ptov(unsigned int phys_addr,unsigned int fn,unsigned int sz)604 static int eeprom_ptov(unsigned int phys_addr, unsigned int fn, unsigned int sz)
605 {
606 fn *= sz;
607 if (phys_addr < 1024)
608 return phys_addr + (31 << 10);
609 if (phys_addr < 1024 + fn)
610 return 31744 - fn + phys_addr - 1024;
611 if (phys_addr < EEPROMSIZE)
612 return phys_addr - 1024 - fn;
613 return -EINVAL;
614 }
615
616 /* The next two routines implement eeprom read/write from physical addresses.
617 */
eeprom_rd_phys(struct adapter * adap,unsigned int phys_addr,u32 * v)618 static int eeprom_rd_phys(struct adapter *adap, unsigned int phys_addr, u32 *v)
619 {
620 int vaddr = eeprom_ptov(phys_addr, adap->fn, EEPROMPFSIZE);
621
622 if (vaddr >= 0)
623 vaddr = pci_read_vpd(adap->pdev, vaddr, sizeof(u32), v);
624 return vaddr < 0 ? vaddr : 0;
625 }
626
eeprom_wr_phys(struct adapter * adap,unsigned int phys_addr,u32 v)627 static int eeprom_wr_phys(struct adapter *adap, unsigned int phys_addr, u32 v)
628 {
629 int vaddr = eeprom_ptov(phys_addr, adap->fn, EEPROMPFSIZE);
630
631 if (vaddr >= 0)
632 vaddr = pci_write_vpd(adap->pdev, vaddr, sizeof(u32), &v);
633 return vaddr < 0 ? vaddr : 0;
634 }
635
636 #define EEPROM_MAGIC 0x38E2F10C
637
get_eeprom(struct net_device * dev,struct ethtool_eeprom * e,u8 * data)638 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
639 u8 *data)
640 {
641 int i, err = 0;
642 struct adapter *adapter = netdev2adap(dev);
643 u8 *buf = kmalloc(EEPROMSIZE, GFP_KERNEL);
644
645 if (!buf)
646 return -ENOMEM;
647
648 e->magic = EEPROM_MAGIC;
649 for (i = e->offset & ~3; !err && i < e->offset + e->len; i += 4)
650 err = eeprom_rd_phys(adapter, i, (u32 *)&buf[i]);
651
652 if (!err)
653 memcpy(data, buf + e->offset, e->len);
654 kfree(buf);
655 return err;
656 }
657
set_eeprom(struct net_device * dev,struct ethtool_eeprom * eeprom,u8 * data)658 static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
659 u8 *data)
660 {
661 u8 *buf;
662 int err = 0;
663 u32 aligned_offset, aligned_len, *p;
664 struct adapter *adapter = netdev2adap(dev);
665
666 if (eeprom->magic != EEPROM_MAGIC)
667 return -EINVAL;
668
669 aligned_offset = eeprom->offset & ~3;
670 aligned_len = (eeprom->len + (eeprom->offset & 3) + 3) & ~3;
671
672 if (adapter->fn > 0) {
673 u32 start = 1024 + adapter->fn * EEPROMPFSIZE;
674
675 if (aligned_offset < start ||
676 aligned_offset + aligned_len > start + EEPROMPFSIZE)
677 return -EPERM;
678 }
679
680 if (aligned_offset != eeprom->offset || aligned_len != eeprom->len) {
681 /* RMW possibly needed for first or last words.
682 */
683 buf = kmalloc(aligned_len, GFP_KERNEL);
684 if (!buf)
685 return -ENOMEM;
686 err = eeprom_rd_phys(adapter, aligned_offset, (u32 *)buf);
687 if (!err && aligned_len > 4)
688 err = eeprom_rd_phys(adapter,
689 aligned_offset + aligned_len - 4,
690 (u32 *)&buf[aligned_len - 4]);
691 if (err)
692 goto out;
693 memcpy(buf + (eeprom->offset & 3), data, eeprom->len);
694 } else {
695 buf = data;
696 }
697
698 err = t4_seeprom_wp(adapter, false);
699 if (err)
700 goto out;
701
702 for (p = (u32 *)buf; !err && aligned_len; aligned_len -= 4, p++) {
703 err = eeprom_wr_phys(adapter, aligned_offset, *p);
704 aligned_offset += 4;
705 }
706
707 if (!err)
708 err = t4_seeprom_wp(adapter, true);
709 out:
710 if (buf != data)
711 kfree(buf);
712 return err;
713 }
714
set_flash(struct net_device * netdev,struct ethtool_flash * ef)715 static int set_flash(struct net_device *netdev, struct ethtool_flash *ef)
716 {
717 int ret;
718 const struct firmware *fw;
719 struct adapter *adap = netdev2adap(netdev);
720 unsigned int mbox = PCIE_FW_MASTER_M + 1;
721
722 ef->data[sizeof(ef->data) - 1] = '\0';
723 ret = request_firmware(&fw, ef->data, adap->pdev_dev);
724 if (ret < 0)
725 return ret;
726
727 /* If the adapter has been fully initialized then we'll go ahead and
728 * try to get the firmware's cooperation in upgrading to the new
729 * firmware image otherwise we'll try to do the entire job from the
730 * host ... and we always "force" the operation in this path.
731 */
732 if (adap->flags & FULL_INIT_DONE)
733 mbox = adap->mbox;
734
735 ret = t4_fw_upgrade(adap, mbox, fw->data, fw->size, 1);
736 release_firmware(fw);
737 if (!ret)
738 dev_info(adap->pdev_dev,
739 "loaded firmware %s, reload cxgb4 driver\n", ef->data);
740 return ret;
741 }
742
743 #define WOL_SUPPORTED (WAKE_BCAST | WAKE_MAGIC)
744 #define BCAST_CRC 0xa0ccc1a6
745
get_wol(struct net_device * dev,struct ethtool_wolinfo * wol)746 static void get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
747 {
748 wol->supported = WAKE_BCAST | WAKE_MAGIC;
749 wol->wolopts = netdev2adap(dev)->wol;
750 memset(&wol->sopass, 0, sizeof(wol->sopass));
751 }
752
set_wol(struct net_device * dev,struct ethtool_wolinfo * wol)753 static int set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
754 {
755 int err = 0;
756 struct port_info *pi = netdev_priv(dev);
757
758 if (wol->wolopts & ~WOL_SUPPORTED)
759 return -EINVAL;
760 t4_wol_magic_enable(pi->adapter, pi->tx_chan,
761 (wol->wolopts & WAKE_MAGIC) ? dev->dev_addr : NULL);
762 if (wol->wolopts & WAKE_BCAST) {
763 err = t4_wol_pat_enable(pi->adapter, pi->tx_chan, 0xfe, ~0ULL,
764 ~0ULL, 0, false);
765 if (!err)
766 err = t4_wol_pat_enable(pi->adapter, pi->tx_chan, 1,
767 ~6ULL, ~0ULL, BCAST_CRC, true);
768 } else {
769 t4_wol_pat_enable(pi->adapter, pi->tx_chan, 0, 0, 0, 0, false);
770 }
771 return err;
772 }
773
get_rss_table_size(struct net_device * dev)774 static u32 get_rss_table_size(struct net_device *dev)
775 {
776 const struct port_info *pi = netdev_priv(dev);
777
778 return pi->rss_size;
779 }
780
get_rss_table(struct net_device * dev,u32 * p,u8 * key,u8 * hfunc)781 static int get_rss_table(struct net_device *dev, u32 *p, u8 *key, u8 *hfunc)
782 {
783 const struct port_info *pi = netdev_priv(dev);
784 unsigned int n = pi->rss_size;
785
786 if (hfunc)
787 *hfunc = ETH_RSS_HASH_TOP;
788 if (!p)
789 return 0;
790 while (n--)
791 p[n] = pi->rss[n];
792 return 0;
793 }
794
set_rss_table(struct net_device * dev,const u32 * p,const u8 * key,const u8 hfunc)795 static int set_rss_table(struct net_device *dev, const u32 *p, const u8 *key,
796 const u8 hfunc)
797 {
798 unsigned int i;
799 struct port_info *pi = netdev_priv(dev);
800
801 /* We require at least one supported parameter to be changed and no
802 * change in any of the unsupported parameters
803 */
804 if (key ||
805 (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
806 return -EOPNOTSUPP;
807 if (!p)
808 return 0;
809
810 for (i = 0; i < pi->rss_size; i++)
811 pi->rss[i] = p[i];
812 if (pi->adapter->flags & FULL_INIT_DONE)
813 return cxgb4_write_rss(pi, pi->rss);
814 return 0;
815 }
816
get_rxnfc(struct net_device * dev,struct ethtool_rxnfc * info,u32 * rules)817 static int get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
818 u32 *rules)
819 {
820 const struct port_info *pi = netdev_priv(dev);
821
822 switch (info->cmd) {
823 case ETHTOOL_GRXFH: {
824 unsigned int v = pi->rss_mode;
825
826 info->data = 0;
827 switch (info->flow_type) {
828 case TCP_V4_FLOW:
829 if (v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F)
830 info->data = RXH_IP_SRC | RXH_IP_DST |
831 RXH_L4_B_0_1 | RXH_L4_B_2_3;
832 else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
833 info->data = RXH_IP_SRC | RXH_IP_DST;
834 break;
835 case UDP_V4_FLOW:
836 if ((v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F) &&
837 (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F))
838 info->data = RXH_IP_SRC | RXH_IP_DST |
839 RXH_L4_B_0_1 | RXH_L4_B_2_3;
840 else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
841 info->data = RXH_IP_SRC | RXH_IP_DST;
842 break;
843 case SCTP_V4_FLOW:
844 case AH_ESP_V4_FLOW:
845 case IPV4_FLOW:
846 if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F)
847 info->data = RXH_IP_SRC | RXH_IP_DST;
848 break;
849 case TCP_V6_FLOW:
850 if (v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F)
851 info->data = RXH_IP_SRC | RXH_IP_DST |
852 RXH_L4_B_0_1 | RXH_L4_B_2_3;
853 else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
854 info->data = RXH_IP_SRC | RXH_IP_DST;
855 break;
856 case UDP_V6_FLOW:
857 if ((v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F) &&
858 (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F))
859 info->data = RXH_IP_SRC | RXH_IP_DST |
860 RXH_L4_B_0_1 | RXH_L4_B_2_3;
861 else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
862 info->data = RXH_IP_SRC | RXH_IP_DST;
863 break;
864 case SCTP_V6_FLOW:
865 case AH_ESP_V6_FLOW:
866 case IPV6_FLOW:
867 if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F)
868 info->data = RXH_IP_SRC | RXH_IP_DST;
869 break;
870 }
871 return 0;
872 }
873 case ETHTOOL_GRXRINGS:
874 info->data = pi->nqsets;
875 return 0;
876 }
877 return -EOPNOTSUPP;
878 }
879
880 static const struct ethtool_ops cxgb_ethtool_ops = {
881 .get_settings = get_settings,
882 .set_settings = set_settings,
883 .get_drvinfo = get_drvinfo,
884 .get_msglevel = get_msglevel,
885 .set_msglevel = set_msglevel,
886 .get_ringparam = get_sge_param,
887 .set_ringparam = set_sge_param,
888 .get_coalesce = get_coalesce,
889 .set_coalesce = set_coalesce,
890 .get_eeprom_len = get_eeprom_len,
891 .get_eeprom = get_eeprom,
892 .set_eeprom = set_eeprom,
893 .get_pauseparam = get_pauseparam,
894 .set_pauseparam = set_pauseparam,
895 .get_link = ethtool_op_get_link,
896 .get_strings = get_strings,
897 .set_phys_id = identify_port,
898 .nway_reset = restart_autoneg,
899 .get_sset_count = get_sset_count,
900 .get_ethtool_stats = get_stats,
901 .get_regs_len = get_regs_len,
902 .get_regs = get_regs,
903 .get_wol = get_wol,
904 .set_wol = set_wol,
905 .get_rxnfc = get_rxnfc,
906 .get_rxfh_indir_size = get_rss_table_size,
907 .get_rxfh = get_rss_table,
908 .set_rxfh = set_rss_table,
909 .flash_device = set_flash,
910 };
911
cxgb4_set_ethtool_ops(struct net_device * netdev)912 void cxgb4_set_ethtool_ops(struct net_device *netdev)
913 {
914 netdev->ethtool_ops = &cxgb_ethtool_ops;
915 }
916