projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cxgb4: Much cleaner implementation of is_t4()/is_t5()
[deliverable/linux.git] / drivers / net / ethernet / chelsio / cxgb4vf / cxgb4vf_main.c
CommitLineData
be839e39
CL		 1/*
2 * This file is part of the Chelsio T4 PCI-E SR-IOV Virtual Function Ethernet
3 * driver for Linux.
4 *
5 * Copyright (c) 2009-2010 Chelsio Communications, Inc. All rights reserved.
6 *
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
12 *
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
16 *
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer.
20 *
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * SOFTWARE.
34 */
35
428ac43f
JP		 36#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
37
be839e39
CL		 38#include <linux/module.h>
39#include <linux/moduleparam.h>
40#include <linux/init.h>
41#include <linux/pci.h>
42#include <linux/dma-mapping.h>
43#include <linux/netdevice.h>
44#include <linux/etherdevice.h>
45#include <linux/debugfs.h>
46#include <linux/ethtool.h>
47
48#include "t4vf_common.h"
49#include "t4vf_defs.h"
50
51#include "../cxgb4/t4_regs.h"
52#include "../cxgb4/t4_msg.h"
53
54/*
55 * Generic information about the driver.
56 */
622c62b5
SR		 57#define DRV_VERSION "2.0.0-ko"
58#define DRV_DESC "Chelsio T4/T5 Virtual Function (VF) Network Driver"
be839e39
CL		 59
60/*
61 * Module Parameters.
62 * ==================
63 */
64
65/*
66 * Default ethtool "message level" for adapters.
67 */
68#define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \
69 NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\
70 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR)
71
72static int dflt_msg_enable = DFLT_MSG_ENABLE;
73
74module_param(dflt_msg_enable, int, 0644);
75MODULE_PARM_DESC(dflt_msg_enable,
76 "default adapter ethtool message level bitmap");
77
78/*
79 * The driver uses the best interrupt scheme available on a platform in the
80 * order MSI-X then MSI. This parameter determines which of these schemes the
81 * driver may consider as follows:
82 *
83 * msi = 2: choose from among MSI-X and MSI
84 * msi = 1: only consider MSI interrupts
85 *
86 * Note that unlike the Physical Function driver, this Virtual Function driver
87 * does _not_ support legacy INTx interrupts (this limitation is mandated by
88 * the PCI-E SR-IOV standard).
89 */
90#define MSI_MSIX 2
91#define MSI_MSI 1
92#define MSI_DEFAULT MSI_MSIX
93
94static int msi = MSI_DEFAULT;
95
96module_param(msi, int, 0644);
97MODULE_PARM_DESC(msi, "whether to use MSI-X or MSI");
98
99/*
100 * Fundamental constants.
101 * ======================
102 */
103
104enum {
105 MAX_TXQ_ENTRIES = 16384,
106 MAX_RSPQ_ENTRIES = 16384,
107 MAX_RX_BUFFERS = 16384,
108
109 MIN_TXQ_ENTRIES = 32,
110 MIN_RSPQ_ENTRIES = 128,
111 MIN_FL_ENTRIES = 16,
112
113 /*
114 * For purposes of manipulating the Free List size we need to
115 * recognize that Free Lists are actually Egress Queues (the host
116 * produces free buffers which the hardware consumes), Egress Queues
117 * indices are all in units of Egress Context Units bytes, and free
118 * list entries are 64-bit PCI DMA addresses. And since the state of
119 * the Producer Index == the Consumer Index implies an EMPTY list, we
120 * always have at least one Egress Unit's worth of Free List entries
121 * unused. See sge.c for more details ...
122 */
123 EQ_UNIT = SGE_EQ_IDXSIZE,
124 FL_PER_EQ_UNIT = EQ_UNIT / sizeof(__be64),
125 MIN_FL_RESID = FL_PER_EQ_UNIT,
126};
127
128/*
129 * Global driver state.
130 * ====================
131 */
132
133static struct dentry *cxgb4vf_debugfs_root;
134
135/*
136 * OS "Callback" functions.
137 * ========================
138 */
139
140/*
141 * The link status has changed on the indicated "port" (Virtual Interface).
142 */
143void t4vf_os_link_changed(struct adapter *adapter, int pidx, int link_ok)
144{
145 struct net_device *dev = adapter->port[pidx];
146
147 /*
148 * If the port is disabled or the current recorded "link up"
149 * status matches the new status, just return.
150 */
151 if (!netif_running(dev) || link_ok == netif_carrier_ok(dev))
152 return;
153
154 /*
155 * Tell the OS that the link status has changed and print a short
156 * informative message on the console about the event.
157 */
158 if (link_ok) {
159 const char *s;
160 const char *fc;
161 const struct port_info *pi = netdev_priv(dev);
162
163 netif_carrier_on(dev);
164
165 switch (pi->link_cfg.speed) {
166 case SPEED_10000:
167 s = "10Gbps";
168 break;
169
170 case SPEED_1000:
171 s = "1000Mbps";
172 break;
173
174 case SPEED_100:
175 s = "100Mbps";
176 break;
177
178 default:
179 s = "unknown";
180 break;
181 }
182
183 switch (pi->link_cfg.fc) {
184 case PAUSE_RX:
185 fc = "RX";
186 break;
187
188 case PAUSE_TX:
189 fc = "TX";
190 break;
191
192 case PAUSE_RX|PAUSE_TX:
193 fc = "RX/TX";
194 break;
195
196 default:
197 fc = "no";
198 break;
199 }
200
428ac43f 201 netdev_info(dev, "link up, %s, full-duplex, %s PAUSE\n", s, fc);
be839e39
CL		 202 } else {
203 netif_carrier_off(dev);
428ac43f 204 netdev_info(dev, "link down\n");
be839e39
CL		 205 }
206}
207
208/*
209 * Net device operations.
210 * ======================
211 */
212
be839e39 213
87737663 214
be839e39
CL		 215
216/*
217 * Perform the MAC and PHY actions needed to enable a "port" (Virtual
218 * Interface).
219 */
220static int link_start(struct net_device *dev)
221{
222 int ret;
223 struct port_info *pi = netdev_priv(dev);
224
225 /*
226 * We do not set address filters and promiscuity here, the stack does
87737663 227 * that step explicitly. Enable vlan accel.
be839e39 228 */
87737663 229 ret = t4vf_set_rxmode(pi->adapter, pi->viid, dev->mtu, -1, -1, -1, 1,
be839e39
CL		 230 true);
231 if (ret == 0) {
232 ret = t4vf_change_mac(pi->adapter, pi->viid,
233 pi->xact_addr_filt, dev->dev_addr, true);
234 if (ret >= 0) {
235 pi->xact_addr_filt = ret;
236 ret = 0;
237 }
238 }
239
240 /*
241 * We don't need to actually "start the link" itself since the
242 * firmware will do that for us when the first Virtual Interface
243 * is enabled on a port.
244 */
245 if (ret == 0)
246 ret = t4vf_enable_vi(pi->adapter, pi->viid, true, true);
247 return ret;
248}
249
250/*
251 * Name the MSI-X interrupts.
252 */
253static void name_msix_vecs(struct adapter *adapter)
254{
255 int namelen = sizeof(adapter->msix_info[0].desc) - 1;
256 int pidx;
257
258 /*
259 * Firmware events.
260 */
261 snprintf(adapter->msix_info[MSIX_FW].desc, namelen,
262 "%s-FWeventq", adapter->name);
263 adapter->msix_info[MSIX_FW].desc[namelen] = 0;
264
265 /*
266 * Ethernet queues.
267 */
268 for_each_port(adapter, pidx) {
269 struct net_device *dev = adapter->port[pidx];
270 const struct port_info *pi = netdev_priv(dev);
271 int qs, msi;
272
caedda35 273 for (qs = 0, msi = MSIX_IQFLINT; qs < pi->nqsets; qs++, msi++) {
be839e39
CL		 274 snprintf(adapter->msix_info[msi].desc, namelen,
275 "%s-%d", dev->name, qs);
276 adapter->msix_info[msi].desc[namelen] = 0;
277 }
278 }
279}
280
281/*
282 * Request all of our MSI-X resources.
283 */
284static int request_msix_queue_irqs(struct adapter *adapter)
285{
286 struct sge *s = &adapter->sge;
287 int rxq, msi, err;
288
289 /*
290 * Firmware events.
291 */
292 err = request_irq(adapter->msix_info[MSIX_FW].vec, t4vf_sge_intr_msix,
293 0, adapter->msix_info[MSIX_FW].desc, &s->fw_evtq);
294 if (err)
295 return err;
296
297 /*
298 * Ethernet queues.
299 */
caedda35 300 msi = MSIX_IQFLINT;
be839e39
CL		 301 for_each_ethrxq(s, rxq) {
302 err = request_irq(adapter->msix_info[msi].vec,
303 t4vf_sge_intr_msix, 0,
304 adapter->msix_info[msi].desc,
305 &s->ethrxq[rxq].rspq);
306 if (err)
307 goto err_free_irqs;
308 msi++;
309 }
310 return 0;
311
312err_free_irqs:
313 while (--rxq >= 0)
314 free_irq(adapter->msix_info[--msi].vec, &s->ethrxq[rxq].rspq);
315 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq);
316 return err;
317}
318
319/*
320 * Free our MSI-X resources.
321 */
322static void free_msix_queue_irqs(struct adapter *adapter)
323{
324 struct sge *s = &adapter->sge;
325 int rxq, msi;
326
327 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq);
caedda35 328 msi = MSIX_IQFLINT;
be839e39
CL		 329 for_each_ethrxq(s, rxq)
330 free_irq(adapter->msix_info[msi++].vec,
331 &s->ethrxq[rxq].rspq);
332}
333
334/*
335 * Turn on NAPI and start up interrupts on a response queue.
336 */
337static void qenable(struct sge_rspq *rspq)
338{
339 napi_enable(&rspq->napi);
340
341 /*
342 * 0-increment the Going To Sleep register to start the timer and
343 * enable interrupts.
344 */
345 t4_write_reg(rspq->adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
346 CIDXINC(0) |
347 SEINTARM(rspq->intr_params) |
348 INGRESSQID(rspq->cntxt_id));
349}
350
351/*
352 * Enable NAPI scheduling and interrupt generation for all Receive Queues.
353 */
354static void enable_rx(struct adapter *adapter)
355{
356 int rxq;
357 struct sge *s = &adapter->sge;
358
359 for_each_ethrxq(s, rxq)
360 qenable(&s->ethrxq[rxq].rspq);
361 qenable(&s->fw_evtq);
362
363 /*
364 * The interrupt queue doesn't use NAPI so we do the 0-increment of
365 * its Going To Sleep register here to get it started.
366 */
367 if (adapter->flags & USING_MSI)
368 t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
369 CIDXINC(0) |
370 SEINTARM(s->intrq.intr_params) |
371 INGRESSQID(s->intrq.cntxt_id));
372
373}
374
375/*
376 * Wait until all NAPI handlers are descheduled.
377 */
378static void quiesce_rx(struct adapter *adapter)
379{
380 struct sge *s = &adapter->sge;
381 int rxq;
382
383 for_each_ethrxq(s, rxq)
384 napi_disable(&s->ethrxq[rxq].rspq.napi);
385 napi_disable(&s->fw_evtq.napi);
386}
387
388/*
389 * Response queue handler for the firmware event queue.
390 */
391static int fwevtq_handler(struct sge_rspq *rspq, const __be64 *rsp,
392 const struct pkt_gl *gl)
393{
394 /*
395 * Extract response opcode and get pointer to CPL message body.
396 */
397 struct adapter *adapter = rspq->adapter;
398 u8 opcode = ((const struct rss_header *)rsp)->opcode;
399 void *cpl = (void *)(rsp + 1);
400
401 switch (opcode) {
402 case CPL_FW6_MSG: {
403 /*
404 * We've received an asynchronous message from the firmware.
405 */
406 const struct cpl_fw6_msg *fw_msg = cpl;
407 if (fw_msg->type == FW6_TYPE_CMD_RPL)
408 t4vf_handle_fw_rpl(adapter, fw_msg->data);
409 break;
410 }
411
94dace10
VP		 412 case CPL_FW4_MSG: {
413 /* FW can send EGR_UPDATEs encapsulated in a CPL_FW4_MSG.
414 */
415 const struct cpl_sge_egr_update *p = (void *)(rsp + 3);
416 opcode = G_CPL_OPCODE(ntohl(p->opcode_qid));
417 if (opcode != CPL_SGE_EGR_UPDATE) {
418 dev_err(adapter->pdev_dev, "unexpected FW4/CPL %#x on FW event queue\n"
419 , opcode);
420 break;
421 }
422 cpl = (void *)p;
423 /*FALLTHROUGH*/
424 }
425
be839e39
CL		 426 case CPL_SGE_EGR_UPDATE: {
427 /*
7f9dd2fa
CL		 428 * We've received an Egress Queue Status Update message. We
429 * get these, if the SGE is configured to send these when the
430 * firmware passes certain points in processing our TX
431 * Ethernet Queue or if we make an explicit request for one.
432 * We use these updates to determine when we may need to
433 * restart a TX Ethernet Queue which was stopped for lack of
434 * free TX Queue Descriptors ...
be839e39 435 */
64699336 436 const struct cpl_sge_egr_update *p = cpl;
be839e39
CL		 437 unsigned int qid = EGR_QID(be32_to_cpu(p->opcode_qid));
438 struct sge *s = &adapter->sge;
439 struct sge_txq *tq;
440 struct sge_eth_txq *txq;
441 unsigned int eq_idx;
be839e39
CL		 442
443 /*
444 * Perform sanity checking on the Queue ID to make sure it
445 * really refers to one of our TX Ethernet Egress Queues which
446 * is active and matches the queue's ID. None of these error
447 * conditions should ever happen so we may want to either make
448 * them fatal and/or conditionalized under DEBUG.
449 */
450 eq_idx = EQ_IDX(s, qid);
451 if (unlikely(eq_idx >= MAX_EGRQ)) {
452 dev_err(adapter->pdev_dev,
453 "Egress Update QID %d out of range\n", qid);
454 break;
455 }
456 tq = s->egr_map[eq_idx];
457 if (unlikely(tq == NULL)) {
458 dev_err(adapter->pdev_dev,
459 "Egress Update QID %d TXQ=NULL\n", qid);
460 break;
461 }
462 txq = container_of(tq, struct sge_eth_txq, q);
463 if (unlikely(tq->abs_id != qid)) {
464 dev_err(adapter->pdev_dev,
465 "Egress Update QID %d refers to TXQ %d\n",
466 qid, tq->abs_id);
467 break;
468 }
469
be839e39
CL		 470 /*
471 * Restart a stopped TX Queue which has less than half of its
472 * TX ring in use ...
473 */
474 txq->q.restarts++;
475 netif_tx_wake_queue(txq->txq);
476 break;
477 }
478
479 default:
480 dev_err(adapter->pdev_dev,
481 "unexpected CPL %#x on FW event queue\n", opcode);
482 }
483
484 return 0;
485}
486
487/*
488 * Allocate SGE TX/RX response queues. Determine how many sets of SGE queues
489 * to use and initializes them. We support multiple "Queue Sets" per port if
490 * we have MSI-X, otherwise just one queue set per port.
491 */
492static int setup_sge_queues(struct adapter *adapter)
493{
494 struct sge *s = &adapter->sge;
495 int err, pidx, msix;
496
497 /*
498 * Clear "Queue Set" Free List Starving and TX Queue Mapping Error
499 * state.
500 */
501 bitmap_zero(s->starving_fl, MAX_EGRQ);
502
503 /*
504 * If we're using MSI interrupt mode we need to set up a "forwarded
505 * interrupt" queue which we'll set up with our MSI vector. The rest
506 * of the ingress queues will be set up to forward their interrupts to
507 * this queue ... This must be first since t4vf_sge_alloc_rxq() uses
508 * the intrq's queue ID as the interrupt forwarding queue for the
509 * subsequent calls ...
510 */
511 if (adapter->flags & USING_MSI) {
512 err = t4vf_sge_alloc_rxq(adapter, &s->intrq, false,
513 adapter->port[0], 0, NULL, NULL);
514 if (err)
515 goto err_free_queues;
516 }
517
518 /*
519 * Allocate our ingress queue for asynchronous firmware messages.
520 */
521 err = t4vf_sge_alloc_rxq(adapter, &s->fw_evtq, true, adapter->port[0],
522 MSIX_FW, NULL, fwevtq_handler);
523 if (err)
524 goto err_free_queues;
525
526 /*
527 * Allocate each "port"'s initial Queue Sets. These can be changed
528 * later on ... up to the point where any interface on the adapter is
529 * brought up at which point lots of things get nailed down
530 * permanently ...
531 */
caedda35 532 msix = MSIX_IQFLINT;
be839e39
CL		 533 for_each_port(adapter, pidx) {
534 struct net_device *dev = adapter->port[pidx];
535 struct port_info *pi = netdev_priv(dev);
536 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset];
537 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset];
be839e39
CL		 538 int qs;
539
c8639a82 540 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
be839e39
CL		 541 err = t4vf_sge_alloc_rxq(adapter, &rxq->rspq, false,
542 dev, msix++,
543 &rxq->fl, t4vf_ethrx_handler);
544 if (err)
545 goto err_free_queues;
546
547 err = t4vf_sge_alloc_eth_txq(adapter, txq, dev,
548 netdev_get_tx_queue(dev, qs),
549 s->fw_evtq.cntxt_id);
550 if (err)
551 goto err_free_queues;
552
553 rxq->rspq.idx = qs;
554 memset(&rxq->stats, 0, sizeof(rxq->stats));
555 }
556 }
557
558 /*
559 * Create the reverse mappings for the queues.
560 */
561 s->egr_base = s->ethtxq[0].q.abs_id - s->ethtxq[0].q.cntxt_id;
562 s->ingr_base = s->ethrxq[0].rspq.abs_id - s->ethrxq[0].rspq.cntxt_id;
563 IQ_MAP(s, s->fw_evtq.abs_id) = &s->fw_evtq;
564 for_each_port(adapter, pidx) {
565 struct net_device *dev = adapter->port[pidx];
566 struct port_info *pi = netdev_priv(dev);
567 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset];
568 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset];
be839e39
CL		 569 int qs;
570
c8639a82 571 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
be839e39
CL		 572 IQ_MAP(s, rxq->rspq.abs_id) = &rxq->rspq;
573 EQ_MAP(s, txq->q.abs_id) = &txq->q;
574
575 /*
576 * The FW_IQ_CMD doesn't return the Absolute Queue IDs
577 * for Free Lists but since all of the Egress Queues
578 * (including Free Lists) have Relative Queue IDs
579 * which are computed as Absolute - Base Queue ID, we
580 * can synthesize the Absolute Queue IDs for the Free
581 * Lists. This is useful for debugging purposes when
582 * we want to dump Queue Contexts via the PF Driver.
583 */
584 rxq->fl.abs_id = rxq->fl.cntxt_id + s->egr_base;
585 EQ_MAP(s, rxq->fl.abs_id) = &rxq->fl;
586 }
587 }
588 return 0;
589
590err_free_queues:
591 t4vf_free_sge_resources(adapter);
592 return err;
593}
594
595/*
596 * Set up Receive Side Scaling (RSS) to distribute packets to multiple receive
597 * queues. We configure the RSS CPU lookup table to distribute to the number
598 * of HW receive queues, and the response queue lookup table to narrow that
599 * down to the response queues actually configured for each "port" (Virtual
600 * Interface). We always configure the RSS mapping for all ports since the
601 * mapping table has plenty of entries.
602 */
603static int setup_rss(struct adapter *adapter)
604{
605 int pidx;
606
607 for_each_port(adapter, pidx) {
608 struct port_info *pi = adap2pinfo(adapter, pidx);
609 struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset];
610 u16 rss[MAX_PORT_QSETS];
611 int qs, err;
612
613 for (qs = 0; qs < pi->nqsets; qs++)
614 rss[qs] = rxq[qs].rspq.abs_id;
615
616 err = t4vf_config_rss_range(adapter, pi->viid,
617 0, pi->rss_size, rss, pi->nqsets);
618 if (err)
619 return err;
620
621 /*
622 * Perform Global RSS Mode-specific initialization.
623 */
624 switch (adapter->params.rss.mode) {
625 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL:
626 /*
627 * If Tunnel All Lookup isn't specified in the global
628 * RSS Configuration, then we need to specify a
629 * default Ingress Queue for any ingress packets which
630 * aren't hashed. We'll use our first ingress queue
631 * ...
632 */
633 if (!adapter->params.rss.u.basicvirtual.tnlalllookup) {
634 union rss_vi_config config;
635 err = t4vf_read_rss_vi_config(adapter,
636 pi->viid,
637 &config);
638 if (err)
639 return err;
640 config.basicvirtual.defaultq =
641 rxq[0].rspq.abs_id;
642 err = t4vf_write_rss_vi_config(adapter,
643 pi->viid,
644 &config);
645 if (err)
646 return err;
647 }
648 break;
649 }
650 }
651
652 return 0;
653}
654
655/*
656 * Bring the adapter up. Called whenever we go from no "ports" open to having
657 * one open. This function performs the actions necessary to make an adapter
658 * operational, such as completing the initialization of HW modules, and
659 * enabling interrupts. Must be called with the rtnl lock held. (Note that
660 * this is called "cxgb_up" in the PF Driver.)
661 */
662static int adapter_up(struct adapter *adapter)
663{
664 int err;
665
666 /*
667 * If this is the first time we've been called, perform basic
668 * adapter setup. Once we've done this, many of our adapter
669 * parameters can no longer be changed ...
670 */
671 if ((adapter->flags & FULL_INIT_DONE) == 0) {
672 err = setup_sge_queues(adapter);
673 if (err)
674 return err;
675 err = setup_rss(adapter);
676 if (err) {
677 t4vf_free_sge_resources(adapter);
678 return err;
679 }
680
681 if (adapter->flags & USING_MSIX)
682 name_msix_vecs(adapter);
683 adapter->flags |= FULL_INIT_DONE;
684 }
685
686 /*
687 * Acquire our interrupt resources. We only support MSI-X and MSI.
688 */
689 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0);
690 if (adapter->flags & USING_MSIX)
691 err = request_msix_queue_irqs(adapter);
692 else
693 err = request_irq(adapter->pdev->irq,
694 t4vf_intr_handler(adapter), 0,
695 adapter->name, adapter);
696 if (err) {
697 dev_err(adapter->pdev_dev, "request_irq failed, err %d\n",
698 err);
699 return err;
700 }
701
702 /*
703 * Enable NAPI ingress processing and return success.
704 */
705 enable_rx(adapter);
706 t4vf_sge_start(adapter);
707 return 0;
708}
709
710/*
711 * Bring the adapter down. Called whenever the last "port" (Virtual
712 * Interface) closed. (Note that this routine is called "cxgb_down" in the PF
713 * Driver.)
714 */
715static void adapter_down(struct adapter *adapter)
716{
717 /*
718 * Free interrupt resources.
719 */
720 if (adapter->flags & USING_MSIX)
721 free_msix_queue_irqs(adapter);
722 else
723 free_irq(adapter->pdev->irq, adapter);
724
725 /*
726 * Wait for NAPI handlers to finish.
727 */
728 quiesce_rx(adapter);
729}
730
731/*
732 * Start up a net device.
733 */
734static int cxgb4vf_open(struct net_device *dev)
735{
736 int err;
737 struct port_info *pi = netdev_priv(dev);
738 struct adapter *adapter = pi->adapter;
739
740 /*
741 * If this is the first interface that we're opening on the "adapter",
742 * bring the "adapter" up now.
743 */
744 if (adapter->open_device_map == 0) {
745 err = adapter_up(adapter);
746 if (err)
747 return err;
748 }
749
750 /*
751 * Note that this interface is up and start everything up ...
752 */
003ab674
BH		 753 netif_set_real_num_tx_queues(dev, pi->nqsets);
754 err = netif_set_real_num_rx_queues(dev, pi->nqsets);
755 if (err)
343a8d13 756 goto err_unwind;
e7a3795f
CL		 757 err = link_start(dev);
758 if (err)
343a8d13
CL		 759 goto err_unwind;
760
be839e39 761 netif_tx_start_all_queues(dev);
343a8d13 762 set_bit(pi->port_id, &adapter->open_device_map);
be839e39 763 return 0;
343a8d13
CL		 764
765err_unwind:
766 if (adapter->open_device_map == 0)
767 adapter_down(adapter);
768 return err;
be839e39
CL		 769}
770
771/*
772 * Shut down a net device. This routine is called "cxgb_close" in the PF
773 * Driver ...
774 */
775static int cxgb4vf_stop(struct net_device *dev)
776{
be839e39
CL		 777 struct port_info *pi = netdev_priv(dev);
778 struct adapter *adapter = pi->adapter;
779
780 netif_tx_stop_all_queues(dev);
781 netif_carrier_off(dev);
343a8d13 782 t4vf_enable_vi(adapter, pi->viid, false, false);
be839e39
CL		 783 pi->link_cfg.link_ok = 0;
784
785 clear_bit(pi->port_id, &adapter->open_device_map);
786 if (adapter->open_device_map == 0)
787 adapter_down(adapter);
788 return 0;
789}
790
791/*
792 * Translate our basic statistics into the standard "ifconfig" statistics.
793 */
794static struct net_device_stats *cxgb4vf_get_stats(struct net_device *dev)
795{
796 struct t4vf_port_stats stats;
797 struct port_info *pi = netdev2pinfo(dev);
798 struct adapter *adapter = pi->adapter;
799 struct net_device_stats *ns = &dev->stats;
800 int err;
801
802 spin_lock(&adapter->stats_lock);
803 err = t4vf_get_port_stats(adapter, pi->pidx, &stats);
804 spin_unlock(&adapter->stats_lock);
805
806 memset(ns, 0, sizeof(*ns));
807 if (err)
808 return ns;
809
810 ns->tx_bytes = (stats.tx_bcast_bytes + stats.tx_mcast_bytes +
811 stats.tx_ucast_bytes + stats.tx_offload_bytes);
812 ns->tx_packets = (stats.tx_bcast_frames + stats.tx_mcast_frames +
813 stats.tx_ucast_frames + stats.tx_offload_frames);
814 ns->rx_bytes = (stats.rx_bcast_bytes + stats.rx_mcast_bytes +
815 stats.rx_ucast_bytes);
816 ns->rx_packets = (stats.rx_bcast_frames + stats.rx_mcast_frames +
817 stats.rx_ucast_frames);
818 ns->multicast = stats.rx_mcast_frames;
819 ns->tx_errors = stats.tx_drop_frames;
820 ns->rx_errors = stats.rx_err_frames;
821
822 return ns;
823}
824
825/*
42eb59d3
CL		 826 * Collect up to maxaddrs worth of a netdevice's unicast addresses, starting
827 * at a specified offset within the list, into an array of addrss pointers and
828 * return the number collected.
be839e39 829 */
42eb59d3
CL		 830static inline unsigned int collect_netdev_uc_list_addrs(const struct net_device *dev,
831 const u8 **addr,
832 unsigned int offset,
833 unsigned int maxaddrs)
be839e39 834{
42eb59d3 835 unsigned int index = 0;
be839e39
CL		 836 unsigned int naddr = 0;
837 const struct netdev_hw_addr *ha;
838
42eb59d3
CL		 839 for_each_dev_addr(dev, ha)
840 if (index++ >= offset) {
841 addr[naddr++] = ha->addr;
842 if (naddr >= maxaddrs)
843 break;
844 }
be839e39
CL		 845 return naddr;
846}
847
848/*
42eb59d3
CL		 849 * Collect up to maxaddrs worth of a netdevice's multicast addresses, starting
850 * at a specified offset within the list, into an array of addrss pointers and
851 * return the number collected.
be839e39 852 */
42eb59d3
CL		 853static inline unsigned int collect_netdev_mc_list_addrs(const struct net_device *dev,
854 const u8 **addr,
855 unsigned int offset,
856 unsigned int maxaddrs)
be839e39 857{
42eb59d3 858 unsigned int index = 0;
be839e39
CL		 859 unsigned int naddr = 0;
860 const struct netdev_hw_addr *ha;
861
42eb59d3
CL		 862 netdev_for_each_mc_addr(ha, dev)
863 if (index++ >= offset) {
864 addr[naddr++] = ha->addr;
865 if (naddr >= maxaddrs)
866 break;
867 }
be839e39
CL		 868 return naddr;
869}
870
871/*
872 * Configure the exact and hash address filters to handle a port's multicast
873 * and secondary unicast MAC addresses.
874 */
875static int set_addr_filters(const struct net_device *dev, bool sleep)
876{
877 u64 mhash = 0;
878 u64 uhash = 0;
879 bool free = true;
42eb59d3 880 unsigned int offset, naddr;
be839e39 881 const u8 *addr[7];
42eb59d3 882 int ret;
be839e39
CL		 883 const struct port_info *pi = netdev_priv(dev);
884
885 /* first do the secondary unicast addresses */
42eb59d3
CL		 886 for (offset = 0; ; offset += naddr) {
887 naddr = collect_netdev_uc_list_addrs(dev, addr, offset,
888 ARRAY_SIZE(addr));
889 if (naddr == 0)
890 break;
891
be839e39 892 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
42eb59d3 893 naddr, addr, NULL, &uhash, sleep);
be839e39
CL		 894 if (ret < 0)
895 return ret;
896
897 free = false;
898 }
899
900 /* next set up the multicast addresses */
42eb59d3
CL		 901 for (offset = 0; ; offset += naddr) {
902 naddr = collect_netdev_mc_list_addrs(dev, addr, offset,
903 ARRAY_SIZE(addr));
904 if (naddr == 0)
905 break;
906
be839e39 907 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
42eb59d3 908 naddr, addr, NULL, &mhash, sleep);
be839e39
CL		 909 if (ret < 0)
910 return ret;
42eb59d3 911 free = false;
be839e39
CL		 912 }
913
914 return t4vf_set_addr_hash(pi->adapter, pi->viid, uhash != 0,
915 uhash | mhash, sleep);
916}
917
918/*
919 * Set RX properties of a port, such as promiscruity, address filters, and MTU.
920 * If @mtu is -1 it is left unchanged.
921 */
922static int set_rxmode(struct net_device *dev, int mtu, bool sleep_ok)
923{
924 int ret;
925 struct port_info *pi = netdev_priv(dev);
926
927 ret = set_addr_filters(dev, sleep_ok);
928 if (ret == 0)
929 ret = t4vf_set_rxmode(pi->adapter, pi->viid, -1,
930 (dev->flags & IFF_PROMISC) != 0,
931 (dev->flags & IFF_ALLMULTI) != 0,
932 1, -1, sleep_ok);
933 return ret;
934}
935
936/*
937 * Set the current receive modes on the device.
938 */
939static void cxgb4vf_set_rxmode(struct net_device *dev)
940{
941 /* unfortunately we can't return errors to the stack */
942 set_rxmode(dev, -1, false);
943}
944
945/*
946 * Find the entry in the interrupt holdoff timer value array which comes
947 * closest to the specified interrupt holdoff value.
948 */
949static int closest_timer(const struct sge *s, int us)
950{
951 int i, timer_idx = 0, min_delta = INT_MAX;
952
953 for (i = 0; i < ARRAY_SIZE(s->timer_val); i++) {
954 int delta = us - s->timer_val[i];
955 if (delta < 0)
956 delta = -delta;
957 if (delta < min_delta) {
958 min_delta = delta;
959 timer_idx = i;
960 }
961 }
962 return timer_idx;
963}
964
965static int closest_thres(const struct sge *s, int thres)
966{
967 int i, delta, pktcnt_idx = 0, min_delta = INT_MAX;
968
969 for (i = 0; i < ARRAY_SIZE(s->counter_val); i++) {
970 delta = thres - s->counter_val[i];
971 if (delta < 0)
972 delta = -delta;
973 if (delta < min_delta) {
974 min_delta = delta;
975 pktcnt_idx = i;
976 }
977 }
978 return pktcnt_idx;
979}
980
981/*
982 * Return a queue's interrupt hold-off time in us. 0 means no timer.
983 */
984static unsigned int qtimer_val(const struct adapter *adapter,
985 const struct sge_rspq *rspq)
986{
987 unsigned int timer_idx = QINTR_TIMER_IDX_GET(rspq->intr_params);
988
989 return timer_idx < SGE_NTIMERS
990 ? adapter->sge.timer_val[timer_idx]
991 : 0;
992}
993
994/**
995 * set_rxq_intr_params - set a queue's interrupt holdoff parameters
996 * @adapter: the adapter
997 * @rspq: the RX response queue
998 * @us: the hold-off time in us, or 0 to disable timer
999 * @cnt: the hold-off packet count, or 0 to disable counter
1000 *
1001 * Sets an RX response queue's interrupt hold-off time and packet count.
1002 * At least one of the two needs to be enabled for the queue to generate
1003 * interrupts.
1004 */
1005static int set_rxq_intr_params(struct adapter *adapter, struct sge_rspq *rspq,
1006 unsigned int us, unsigned int cnt)
1007{
1008 unsigned int timer_idx;
1009
1010 /*
1011 * If both the interrupt holdoff timer and count are specified as
1012 * zero, default to a holdoff count of 1 ...
1013 */
1014 if ((us | cnt) == 0)
1015 cnt = 1;
1016
1017 /*
1018 * If an interrupt holdoff count has been specified, then find the
1019 * closest configured holdoff count and use that. If the response
1020 * queue has already been created, then update its queue context
1021 * parameters ...
1022 */
1023 if (cnt) {
1024 int err;
1025 u32 v, pktcnt_idx;
1026
1027 pktcnt_idx = closest_thres(&adapter->sge, cnt);
1028 if (rspq->desc && rspq->pktcnt_idx != pktcnt_idx) {
1029 v = FW_PARAMS_MNEM(FW_PARAMS_MNEM_DMAQ) |
1030 FW_PARAMS_PARAM_X(
1031 FW_PARAMS_PARAM_DMAQ_IQ_INTCNTTHRESH) |
1032 FW_PARAMS_PARAM_YZ(rspq->cntxt_id);
1033 err = t4vf_set_params(adapter, 1, &v, &pktcnt_idx);
1034 if (err)
1035 return err;
1036 }
1037 rspq->pktcnt_idx = pktcnt_idx;
1038 }
1039
1040 /*
1041 * Compute the closest holdoff timer index from the supplied holdoff
1042 * timer value.
1043 */
1044 timer_idx = (us == 0
1045 ? SGE_TIMER_RSTRT_CNTR
1046 : closest_timer(&adapter->sge, us));
1047
1048 /*
1049 * Update the response queue's interrupt coalescing parameters and
1050 * return success.
1051 */
1052 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
1053 (cnt > 0 ? QINTR_CNT_EN : 0));
1054 return 0;
1055}
1056
1057/*
1058 * Return a version number to identify the type of adapter. The scheme is:
1059 * - bits 0..9: chip version
1060 * - bits 10..15: chip revision
1061 */
1062static inline unsigned int mk_adap_vers(const struct adapter *adapter)
1063{
1064 /*
1065 * Chip version 4, revision 0x3f (cxgb4vf).
1066 */
622c62b5 1067 return CHELSIO_CHIP_VERSION(adapter->chip) | (0x3f << 10);
be839e39
CL		 1068}
1069
1070/*
1071 * Execute the specified ioctl command.
1072 */
1073static int cxgb4vf_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1074{
1075 int ret = 0;
1076
1077 switch (cmd) {
1078 /*
1079 * The VF Driver doesn't have access to any of the other
1080 * common Ethernet device ioctl()'s (like reading/writing
1081 * PHY registers, etc.
1082 */
1083
1084 default:
1085 ret = -EOPNOTSUPP;
1086 break;
1087 }
1088 return ret;
1089}
1090
1091/*
1092 * Change the device's MTU.
1093 */
1094static int cxgb4vf_change_mtu(struct net_device *dev, int new_mtu)
1095{
1096 int ret;
1097 struct port_info *pi = netdev_priv(dev);
1098
1099 /* accommodate SACK */
1100 if (new_mtu < 81)
1101 return -EINVAL;
1102
1103 ret = t4vf_set_rxmode(pi->adapter, pi->viid, new_mtu,
1104 -1, -1, -1, -1, true);
1105 if (!ret)
1106 dev->mtu = new_mtu;
1107 return ret;
1108}
1109
c8f44aff
MM		 1110static netdev_features_t cxgb4vf_fix_features(struct net_device *dev,
1111 netdev_features_t features)
87737663
JP		 1112{
1113 /*
1114 * Since there is no support for separate rx/tx vlan accel
1115 * enable/disable make sure tx flag is always in same state as rx.
1116 */
f646968f
PM		 1117 if (features & NETIF_F_HW_VLAN_CTAG_RX)
1118 features |= NETIF_F_HW_VLAN_CTAG_TX;
87737663 1119 else
f646968f 1120 features &= ~NETIF_F_HW_VLAN_CTAG_TX;
87737663
JP		 1121
1122 return features;
1123}
1124
c8f44aff
MM		 1125static int cxgb4vf_set_features(struct net_device *dev,
1126 netdev_features_t features)
87737663
JP		 1127{
1128 struct port_info *pi = netdev_priv(dev);
c8f44aff 1129 netdev_features_t changed = dev->features ^ features;
87737663 1130
f646968f 1131 if (changed & NETIF_F_HW_VLAN_CTAG_RX)
87737663 1132 t4vf_set_rxmode(pi->adapter, pi->viid, -1, -1, -1, -1,
f646968f 1133 features & NETIF_F_HW_VLAN_CTAG_TX, 0);
87737663
JP		 1134
1135 return 0;
1136}
1137
be839e39
CL		 1138/*
1139 * Change the devices MAC address.
1140 */
1141static int cxgb4vf_set_mac_addr(struct net_device *dev, void *_addr)
1142{
1143 int ret;
1144 struct sockaddr *addr = _addr;
1145 struct port_info *pi = netdev_priv(dev);
1146
1147 if (!is_valid_ether_addr(addr->sa_data))
504f9b5a 1148 return -EADDRNOTAVAIL;
be839e39
CL		 1149
1150 ret = t4vf_change_mac(pi->adapter, pi->viid, pi->xact_addr_filt,
1151 addr->sa_data, true);
1152 if (ret < 0)
1153 return ret;
1154
1155 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1156 pi->xact_addr_filt = ret;
1157 return 0;
1158}
1159
be839e39
CL		 1160#ifdef CONFIG_NET_POLL_CONTROLLER
1161/*
1162 * Poll all of our receive queues. This is called outside of normal interrupt
1163 * context.
1164 */
1165static void cxgb4vf_poll_controller(struct net_device *dev)
1166{
1167 struct port_info *pi = netdev_priv(dev);
1168 struct adapter *adapter = pi->adapter;
1169
1170 if (adapter->flags & USING_MSIX) {
1171 struct sge_eth_rxq *rxq;
1172 int nqsets;
1173
1174 rxq = &adapter->sge.ethrxq[pi->first_qset];
1175 for (nqsets = pi->nqsets; nqsets; nqsets--) {
1176 t4vf_sge_intr_msix(0, &rxq->rspq);
1177 rxq++;
1178 }
1179 } else
1180 t4vf_intr_handler(adapter)(0, adapter);
1181}
1182#endif
1183
1184/*
1185 * Ethtool operations.
1186 * ===================
1187 *
1188 * Note that we don't support any ethtool operations which change the physical
1189 * state of the port to which we're linked.
1190 */
1191
1192/*
1193 * Return current port link settings.
1194 */
1195static int cxgb4vf_get_settings(struct net_device *dev,
1196 struct ethtool_cmd *cmd)
1197{
1198 const struct port_info *pi = netdev_priv(dev);
1199
1200 cmd->supported = pi->link_cfg.supported;
1201 cmd->advertising = pi->link_cfg.advertising;
70739497
DD		 1202 ethtool_cmd_speed_set(cmd,
1203 netif_carrier_ok(dev) ? pi->link_cfg.speed : -1);
be839e39
CL		 1204 cmd->duplex = DUPLEX_FULL;
1205
1206 cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
1207 cmd->phy_address = pi->port_id;
1208 cmd->transceiver = XCVR_EXTERNAL;
1209 cmd->autoneg = pi->link_cfg.autoneg;
1210 cmd->maxtxpkt = 0;
1211 cmd->maxrxpkt = 0;
1212 return 0;
1213}
1214
1215/*
1216 * Return our driver information.
1217 */
1218static void cxgb4vf_get_drvinfo(struct net_device *dev,
1219 struct ethtool_drvinfo *drvinfo)
1220{
1221 struct adapter *adapter = netdev2adap(dev);
1222
23020ab3
RJ		 1223 strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
1224 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
1225 strlcpy(drvinfo->bus_info, pci_name(to_pci_dev(dev->dev.parent)),
1226 sizeof(drvinfo->bus_info));
be839e39
CL		 1227 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1228 "%u.%u.%u.%u, TP %u.%u.%u.%u",
1229 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.fwrev),
1230 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.fwrev),
1231 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.fwrev),
1232 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.fwrev),
1233 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.tprev),
1234 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.tprev),
1235 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.tprev),
1236 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.tprev));
1237}
1238
1239/*
1240 * Return current adapter message level.
1241 */
1242static u32 cxgb4vf_get_msglevel(struct net_device *dev)
1243{
1244 return netdev2adap(dev)->msg_enable;
1245}
1246
1247/*
1248 * Set current adapter message level.
1249 */
1250static void cxgb4vf_set_msglevel(struct net_device *dev, u32 msglevel)
1251{
1252 netdev2adap(dev)->msg_enable = msglevel;
1253}
1254
1255/*
1256 * Return the device's current Queue Set ring size parameters along with the
1257 * allowed maximum values. Since ethtool doesn't understand the concept of
1258 * multi-queue devices, we just return the current values associated with the
1259 * first Queue Set.
1260 */
1261static void cxgb4vf_get_ringparam(struct net_device *dev,
1262 struct ethtool_ringparam *rp)
1263{
1264 const struct port_info *pi = netdev_priv(dev);
1265 const struct sge *s = &pi->adapter->sge;
1266
1267 rp->rx_max_pending = MAX_RX_BUFFERS;
1268 rp->rx_mini_max_pending = MAX_RSPQ_ENTRIES;
1269 rp->rx_jumbo_max_pending = 0;
1270 rp->tx_max_pending = MAX_TXQ_ENTRIES;
1271
1272 rp->rx_pending = s->ethrxq[pi->first_qset].fl.size - MIN_FL_RESID;
1273 rp->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size;
1274 rp->rx_jumbo_pending = 0;
1275 rp->tx_pending = s->ethtxq[pi->first_qset].q.size;
1276}
1277
1278/*
1279 * Set the Queue Set ring size parameters for the device. Again, since
1280 * ethtool doesn't allow for the concept of multiple queues per device, we'll
1281 * apply these new values across all of the Queue Sets associated with the
1282 * device -- after vetting them of course!
1283 */
1284static int cxgb4vf_set_ringparam(struct net_device *dev,
1285 struct ethtool_ringparam *rp)
1286{
1287 const struct port_info *pi = netdev_priv(dev);
1288 struct adapter *adapter = pi->adapter;
1289 struct sge *s = &adapter->sge;
1290 int qs;
1291
1292 if (rp->rx_pending > MAX_RX_BUFFERS ||
1293 rp->rx_jumbo_pending ||
1294 rp->tx_pending > MAX_TXQ_ENTRIES ||
1295 rp->rx_mini_pending > MAX_RSPQ_ENTRIES ||
1296 rp->rx_mini_pending < MIN_RSPQ_ENTRIES ||
1297 rp->rx_pending < MIN_FL_ENTRIES ||
1298 rp->tx_pending < MIN_TXQ_ENTRIES)
1299 return -EINVAL;
1300
1301 if (adapter->flags & FULL_INIT_DONE)
1302 return -EBUSY;
1303
1304 for (qs = pi->first_qset; qs < pi->first_qset + pi->nqsets; qs++) {
1305 s->ethrxq[qs].fl.size = rp->rx_pending + MIN_FL_RESID;
1306 s->ethrxq[qs].rspq.size = rp->rx_mini_pending;
1307 s->ethtxq[qs].q.size = rp->tx_pending;
1308 }
1309 return 0;
1310}
1311
1312/*
1313 * Return the interrupt holdoff timer and count for the first Queue Set on the
1314 * device. Our extension ioctl() (the cxgbtool interface) allows the
1315 * interrupt holdoff timer to be read on all of the device's Queue Sets.
1316 */
1317static int cxgb4vf_get_coalesce(struct net_device *dev,
1318 struct ethtool_coalesce *coalesce)
1319{
1320 const struct port_info *pi = netdev_priv(dev);
1321 const struct adapter *adapter = pi->adapter;
1322 const struct sge_rspq *rspq = &adapter->sge.ethrxq[pi->first_qset].rspq;
1323
1324 coalesce->rx_coalesce_usecs = qtimer_val(adapter, rspq);
1325 coalesce->rx_max_coalesced_frames =
1326 ((rspq->intr_params & QINTR_CNT_EN)
1327 ? adapter->sge.counter_val[rspq->pktcnt_idx]
1328 : 0);
1329 return 0;
1330}
1331
1332/*
1333 * Set the RX interrupt holdoff timer and count for the first Queue Set on the
1334 * interface. Our extension ioctl() (the cxgbtool interface) allows us to set
1335 * the interrupt holdoff timer on any of the device's Queue Sets.
1336 */
1337static int cxgb4vf_set_coalesce(struct net_device *dev,
1338 struct ethtool_coalesce *coalesce)
1339{
1340 const struct port_info *pi = netdev_priv(dev);
1341 struct adapter *adapter = pi->adapter;
1342
1343 return set_rxq_intr_params(adapter,
1344 &adapter->sge.ethrxq[pi->first_qset].rspq,
1345 coalesce->rx_coalesce_usecs,
1346 coalesce->rx_max_coalesced_frames);
1347}
1348
1349/*
1350 * Report current port link pause parameter settings.
1351 */
1352static void cxgb4vf_get_pauseparam(struct net_device *dev,
1353 struct ethtool_pauseparam *pauseparam)
1354{
1355 struct port_info *pi = netdev_priv(dev);
1356
1357 pauseparam->autoneg = (pi->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
1358 pauseparam->rx_pause = (pi->link_cfg.fc & PAUSE_RX) != 0;
1359 pauseparam->tx_pause = (pi->link_cfg.fc & PAUSE_TX) != 0;
1360}
1361
be839e39
CL		 1362/*
1363 * Identify the port by blinking the port's LED.
1364 */
857a3d0f
DM		 1365static int cxgb4vf_phys_id(struct net_device *dev,
1366 enum ethtool_phys_id_state state)
be839e39 1367{
857a3d0f 1368 unsigned int val;
be839e39
CL		 1369 struct port_info *pi = netdev_priv(dev);
1370
857a3d0f
DM		 1371 if (state == ETHTOOL_ID_ACTIVE)
1372 val = 0xffff;
1373 else if (state == ETHTOOL_ID_INACTIVE)
1374 val = 0;
1375 else
1376 return -EINVAL;
1377
1378 return t4vf_identify_port(pi->adapter, pi->viid, val);
be839e39
CL		 1379}
1380
1381/*
1382 * Port stats maintained per queue of the port.
1383 */
1384struct queue_port_stats {
1385 u64 tso;
1386 u64 tx_csum;
1387 u64 rx_csum;
1388 u64 vlan_ex;
1389 u64 vlan_ins;
f12fe353
CL		 1390 u64 lro_pkts;
1391 u64 lro_merged;
be839e39
CL		 1392};
1393
1394/*
1395 * Strings for the ETH_SS_STATS statistics set ("ethtool -S"). Note that
1396 * these need to match the order of statistics returned by
1397 * t4vf_get_port_stats().
1398 */
1399static const char stats_strings[][ETH_GSTRING_LEN] = {
1400 /*
1401 * These must match the layout of the t4vf_port_stats structure.
1402 */
1403 "TxBroadcastBytes ",
1404 "TxBroadcastFrames ",
1405 "TxMulticastBytes ",
1406 "TxMulticastFrames ",
1407 "TxUnicastBytes ",
1408 "TxUnicastFrames ",
1409 "TxDroppedFrames ",
1410 "TxOffloadBytes ",
1411 "TxOffloadFrames ",
1412 "RxBroadcastBytes ",
1413 "RxBroadcastFrames ",
1414 "RxMulticastBytes ",
1415 "RxMulticastFrames ",
1416 "RxUnicastBytes ",
1417 "RxUnicastFrames ",
1418 "RxErrorFrames ",
1419
1420 /*
1421 * These are accumulated per-queue statistics and must match the
1422 * order of the fields in the queue_port_stats structure.
1423 */
1424 "TSO ",
1425 "TxCsumOffload ",
1426 "RxCsumGood ",
1427 "VLANextractions ",
1428 "VLANinsertions ",
f12fe353
CL		 1429 "GROPackets ",
1430 "GROMerged ",
be839e39
CL		 1431};
1432
1433/*
1434 * Return the number of statistics in the specified statistics set.
1435 */
1436static int cxgb4vf_get_sset_count(struct net_device *dev, int sset)
1437{
1438 switch (sset) {
1439 case ETH_SS_STATS:
1440 return ARRAY_SIZE(stats_strings);
1441 default:
1442 return -EOPNOTSUPP;
1443 }
1444 /*NOTREACHED*/
1445}
1446
1447/*
1448 * Return the strings for the specified statistics set.
1449 */
1450static void cxgb4vf_get_strings(struct net_device *dev,
1451 u32 sset,
1452 u8 *data)
1453{
1454 switch (sset) {
1455 case ETH_SS_STATS:
1456 memcpy(data, stats_strings, sizeof(stats_strings));
1457 break;
1458 }
1459}
1460
1461/*
1462 * Small utility routine to accumulate queue statistics across the queues of
1463 * a "port".
1464 */
1465static void collect_sge_port_stats(const struct adapter *adapter,
1466 const struct port_info *pi,
1467 struct queue_port_stats *stats)
1468{
1469 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[pi->first_qset];
1470 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset];
1471 int qs;
1472
1473 memset(stats, 0, sizeof(*stats));
1474 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
1475 stats->tso += txq->tso;
1476 stats->tx_csum += txq->tx_cso;
1477 stats->rx_csum += rxq->stats.rx_cso;
1478 stats->vlan_ex += rxq->stats.vlan_ex;
1479 stats->vlan_ins += txq->vlan_ins;
f12fe353
CL		 1480 stats->lro_pkts += rxq->stats.lro_pkts;
1481 stats->lro_merged += rxq->stats.lro_merged;
be839e39
CL		 1482 }
1483}
1484
1485/*
1486 * Return the ETH_SS_STATS statistics set.
1487 */
1488static void cxgb4vf_get_ethtool_stats(struct net_device *dev,
1489 struct ethtool_stats *stats,
1490 u64 *data)
1491{
1492 struct port_info *pi = netdev2pinfo(dev);
1493 struct adapter *adapter = pi->adapter;
1494 int err = t4vf_get_port_stats(adapter, pi->pidx,
1495 (struct t4vf_port_stats *)data);
1496 if (err)
1497 memset(data, 0, sizeof(struct t4vf_port_stats));
1498
1499 data += sizeof(struct t4vf_port_stats) / sizeof(u64);
1500 collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
1501}
1502
1503/*
1504 * Return the size of our register map.
1505 */
1506static int cxgb4vf_get_regs_len(struct net_device *dev)
1507{
1508 return T4VF_REGMAP_SIZE;
1509}
1510
1511/*
1512 * Dump a block of registers, start to end inclusive, into a buffer.
1513 */
1514static void reg_block_dump(struct adapter *adapter, void *regbuf,
1515 unsigned int start, unsigned int end)
1516{
1517 u32 *bp = regbuf + start - T4VF_REGMAP_START;
1518
1519 for ( ; start <= end; start += sizeof(u32)) {
1520 /*
1521 * Avoid reading the Mailbox Control register since that
1522 * can trigger a Mailbox Ownership Arbitration cycle and
1523 * interfere with communication with the firmware.
1524 */
1525 if (start == T4VF_CIM_BASE_ADDR + CIM_VF_EXT_MAILBOX_CTRL)
1526 *bp++ = 0xffff;
1527 else
1528 *bp++ = t4_read_reg(adapter, start);
1529 }
1530}
1531
1532/*
1533 * Copy our entire register map into the provided buffer.
1534 */
1535static void cxgb4vf_get_regs(struct net_device *dev,
1536 struct ethtool_regs *regs,
1537 void *regbuf)
1538{
1539 struct adapter *adapter = netdev2adap(dev);
1540
1541 regs->version = mk_adap_vers(adapter);
1542
1543 /*
1544 * Fill in register buffer with our register map.
1545 */
1546 memset(regbuf, 0, T4VF_REGMAP_SIZE);
1547
1548 reg_block_dump(adapter, regbuf,
1549 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_FIRST,
1550 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_LAST);
1551 reg_block_dump(adapter, regbuf,
1552 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_FIRST,
1553 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_LAST);
1554 reg_block_dump(adapter, regbuf,
1555 T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_FIRST,
1556 T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_LAST);
1557 reg_block_dump(adapter, regbuf,
1558 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_FIRST,
1559 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_LAST);
1560
1561 reg_block_dump(adapter, regbuf,
1562 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_FIRST,
1563 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_LAST);
1564}
1565
1566/*
1567 * Report current Wake On LAN settings.
1568 */
1569static void cxgb4vf_get_wol(struct net_device *dev,
1570 struct ethtool_wolinfo *wol)
1571{
1572 wol->supported = 0;
1573 wol->wolopts = 0;
1574 memset(&wol->sopass, 0, sizeof(wol->sopass));
1575}
1576
410989f6
CL		 1577/*
1578 * TCP Segmentation Offload flags which we support.
1579 */
1580#define TSO_FLAGS (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
1581
9b07be4b 1582static const struct ethtool_ops cxgb4vf_ethtool_ops = {
be839e39
CL		 1583 .get_settings = cxgb4vf_get_settings,
1584 .get_drvinfo = cxgb4vf_get_drvinfo,
1585 .get_msglevel = cxgb4vf_get_msglevel,
1586 .set_msglevel = cxgb4vf_set_msglevel,
1587 .get_ringparam = cxgb4vf_get_ringparam,
1588 .set_ringparam = cxgb4vf_set_ringparam,
1589 .get_coalesce = cxgb4vf_get_coalesce,
1590 .set_coalesce = cxgb4vf_set_coalesce,
1591 .get_pauseparam = cxgb4vf_get_pauseparam,
be839e39
CL		 1592 .get_link = ethtool_op_get_link,
1593 .get_strings = cxgb4vf_get_strings,
857a3d0f 1594 .set_phys_id = cxgb4vf_phys_id,
be839e39
CL		 1595 .get_sset_count = cxgb4vf_get_sset_count,
1596 .get_ethtool_stats = cxgb4vf_get_ethtool_stats,
1597 .get_regs_len = cxgb4vf_get_regs_len,
1598 .get_regs = cxgb4vf_get_regs,
1599 .get_wol = cxgb4vf_get_wol,
be839e39
CL		 1600};
1601
1602/*
1603 * /sys/kernel/debug/cxgb4vf support code and data.
1604 * ================================================
1605 */
1606
1607/*
1608 * Show SGE Queue Set information. We display QPL Queues Sets per line.
1609 */
1610#define QPL 4
1611
1612static int sge_qinfo_show(struct seq_file *seq, void *v)
1613{
1614 struct adapter *adapter = seq->private;
1615 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1616 int qs, r = (uintptr_t)v - 1;
1617
1618 if (r)
1619 seq_putc(seq, '\n');
1620
1621 #define S3(fmt_spec, s, v) \
1622 do {\
1623 seq_printf(seq, "%-12s", s); \
1624 for (qs = 0; qs < n; ++qs) \
1625 seq_printf(seq, " %16" fmt_spec, v); \
1626 seq_putc(seq, '\n'); \
1627 } while (0)
1628 #define S(s, v) S3("s", s, v)
1629 #define T(s, v) S3("u", s, txq[qs].v)
1630 #define R(s, v) S3("u", s, rxq[qs].v)
1631
1632 if (r < eth_entries) {
1633 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1634 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1635 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1636
1637 S("QType:", "Ethernet");
1638 S("Interface:",
1639 (rxq[qs].rspq.netdev
1640 ? rxq[qs].rspq.netdev->name
1641 : "N/A"));
1642 S3("d", "Port:",
1643 (rxq[qs].rspq.netdev
1644 ? ((struct port_info *)
1645 netdev_priv(rxq[qs].rspq.netdev))->port_id
1646 : -1));
1647 T("TxQ ID:", q.abs_id);
1648 T("TxQ size:", q.size);
1649 T("TxQ inuse:", q.in_use);
1650 T("TxQ PIdx:", q.pidx);
1651 T("TxQ CIdx:", q.cidx);
1652 R("RspQ ID:", rspq.abs_id);
1653 R("RspQ size:", rspq.size);
1654 R("RspQE size:", rspq.iqe_len);
1655 S3("u", "Intr delay:", qtimer_val(adapter, &rxq[qs].rspq));
1656 S3("u", "Intr pktcnt:",
1657 adapter->sge.counter_val[rxq[qs].rspq.pktcnt_idx]);
1658 R("RspQ CIdx:", rspq.cidx);
1659 R("RspQ Gen:", rspq.gen);
1660 R("FL ID:", fl.abs_id);
1661 R("FL size:", fl.size - MIN_FL_RESID);
1662 R("FL avail:", fl.avail);
1663 R("FL PIdx:", fl.pidx);
1664 R("FL CIdx:", fl.cidx);
1665 return 0;
1666 }
1667
1668 r -= eth_entries;
1669 if (r == 0) {
1670 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1671
1672 seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue");
1673 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id);
1674 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1675 qtimer_val(adapter, evtq));
1676 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1677 adapter->sge.counter_val[evtq->pktcnt_idx]);
1678 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", evtq->cidx);
1679 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen);
1680 } else if (r == 1) {
1681 const struct sge_rspq *intrq = &adapter->sge.intrq;
1682
1683 seq_printf(seq, "%-12s %16s\n", "QType:", "Interrupt Queue");
1684 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", intrq->abs_id);
1685 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1686 qtimer_val(adapter, intrq));
1687 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1688 adapter->sge.counter_val[intrq->pktcnt_idx]);
1689 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", intrq->cidx);
1690 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", intrq->gen);
1691 }
1692
1693 #undef R
1694 #undef T
1695 #undef S
1696 #undef S3
1697
1698 return 0;
1699}
1700
1701/*
1702 * Return the number of "entries" in our "file". We group the multi-Queue
1703 * sections with QPL Queue Sets per "entry". The sections of the output are:
1704 *
1705 * Ethernet RX/TX Queue Sets
1706 * Firmware Event Queue
1707 * Forwarded Interrupt Queue (if in MSI mode)
1708 */
1709static int sge_queue_entries(const struct adapter *adapter)
1710{
1711 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1712 ((adapter->flags & USING_MSI) != 0);
1713}
1714
1715static void *sge_queue_start(struct seq_file *seq, loff_t *pos)
1716{
1717 int entries = sge_queue_entries(seq->private);
1718
1719 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1720}
1721
1722static void sge_queue_stop(struct seq_file *seq, void *v)
1723{
1724}
1725
1726static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos)
1727{
1728 int entries = sge_queue_entries(seq->private);
1729
1730 ++*pos;
1731 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1732}
1733
1734static const struct seq_operations sge_qinfo_seq_ops = {
1735 .start = sge_queue_start,
1736 .next = sge_queue_next,
1737 .stop = sge_queue_stop,
1738 .show = sge_qinfo_show
1739};
1740
1741static int sge_qinfo_open(struct inode *inode, struct file *file)
1742{
1743 int res = seq_open(file, &sge_qinfo_seq_ops);
1744
1745 if (!res) {
1746 struct seq_file *seq = file->private_data;
1747 seq->private = inode->i_private;
1748 }
1749 return res;
1750}
1751
1752static const struct file_operations sge_qinfo_debugfs_fops = {
1753 .owner = THIS_MODULE,
1754 .open = sge_qinfo_open,
1755 .read = seq_read,
1756 .llseek = seq_lseek,
1757 .release = seq_release,
1758};
1759
1760/*
1761 * Show SGE Queue Set statistics. We display QPL Queues Sets per line.
1762 */
1763#define QPL 4
1764
1765static int sge_qstats_show(struct seq_file *seq, void *v)
1766{
1767 struct adapter *adapter = seq->private;
1768 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1769 int qs, r = (uintptr_t)v - 1;
1770
1771 if (r)
1772 seq_putc(seq, '\n');
1773
1774 #define S3(fmt, s, v) \
1775 do { \
1776 seq_printf(seq, "%-16s", s); \
1777 for (qs = 0; qs < n; ++qs) \
1778 seq_printf(seq, " %8" fmt, v); \
1779 seq_putc(seq, '\n'); \
1780 } while (0)
1781 #define S(s, v) S3("s", s, v)
1782
1783 #define T3(fmt, s, v) S3(fmt, s, txq[qs].v)
1784 #define T(s, v) T3("lu", s, v)
1785
1786 #define R3(fmt, s, v) S3(fmt, s, rxq[qs].v)
1787 #define R(s, v) R3("lu", s, v)
1788
1789 if (r < eth_entries) {
1790 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1791 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1792 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1793
1794 S("QType:", "Ethernet");
1795 S("Interface:",
1796 (rxq[qs].rspq.netdev
1797 ? rxq[qs].rspq.netdev->name
1798 : "N/A"));
68dc9d36 1799 R3("u", "RspQNullInts:", rspq.unhandled_irqs);
be839e39
CL		 1800 R("RxPackets:", stats.pkts);
1801 R("RxCSO:", stats.rx_cso);
1802 R("VLANxtract:", stats.vlan_ex);
1803 R("LROmerged:", stats.lro_merged);
1804 R("LROpackets:", stats.lro_pkts);
1805 R("RxDrops:", stats.rx_drops);
1806 T("TSO:", tso);
1807 T("TxCSO:", tx_cso);
1808 T("VLANins:", vlan_ins);
1809 T("TxQFull:", q.stops);
1810 T("TxQRestarts:", q.restarts);
1811 T("TxMapErr:", mapping_err);
1812 R("FLAllocErr:", fl.alloc_failed);
1813 R("FLLrgAlcErr:", fl.large_alloc_failed);
1814 R("FLStarving:", fl.starving);
1815 return 0;
1816 }
1817
1818 r -= eth_entries;
1819 if (r == 0) {
1820 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1821
1822 seq_printf(seq, "%-8s %16s\n", "QType:", "FW event queue");
68dc9d36
CL		 1823 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1824 evtq->unhandled_irqs);
be839e39
CL		 1825 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", evtq->cidx);
1826 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", evtq->gen);
1827 } else if (r == 1) {
1828 const struct sge_rspq *intrq = &adapter->sge.intrq;
1829
1830 seq_printf(seq, "%-8s %16s\n", "QType:", "Interrupt Queue");
68dc9d36
CL		 1831 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1832 intrq->unhandled_irqs);
be839e39
CL		 1833 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", intrq->cidx);
1834 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", intrq->gen);
1835 }
1836
1837 #undef R
1838 #undef T
1839 #undef S
1840 #undef R3
1841 #undef T3
1842 #undef S3
1843
1844 return 0;
1845}
1846
1847/*
1848 * Return the number of "entries" in our "file". We group the multi-Queue
1849 * sections with QPL Queue Sets per "entry". The sections of the output are:
1850 *
1851 * Ethernet RX/TX Queue Sets
1852 * Firmware Event Queue
1853 * Forwarded Interrupt Queue (if in MSI mode)
1854 */
1855static int sge_qstats_entries(const struct adapter *adapter)
1856{
1857 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1858 ((adapter->flags & USING_MSI) != 0);
1859}
1860
1861static void *sge_qstats_start(struct seq_file *seq, loff_t *pos)
1862{
1863 int entries = sge_qstats_entries(seq->private);
1864
1865 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1866}
1867
1868static void sge_qstats_stop(struct seq_file *seq, void *v)
1869{
1870}
1871
1872static void *sge_qstats_next(struct seq_file *seq, void *v, loff_t *pos)
1873{
1874 int entries = sge_qstats_entries(seq->private);
1875
1876 (*pos)++;
1877 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1878}
1879
1880static const struct seq_operations sge_qstats_seq_ops = {
1881 .start = sge_qstats_start,
1882 .next = sge_qstats_next,
1883 .stop = sge_qstats_stop,
1884 .show = sge_qstats_show
1885};
1886
1887static int sge_qstats_open(struct inode *inode, struct file *file)
1888{
1889 int res = seq_open(file, &sge_qstats_seq_ops);
1890
1891 if (res == 0) {
1892 struct seq_file *seq = file->private_data;
1893 seq->private = inode->i_private;
1894 }
1895 return res;
1896}
1897
1898static const struct file_operations sge_qstats_proc_fops = {
1899 .owner = THIS_MODULE,
1900 .open = sge_qstats_open,
1901 .read = seq_read,
1902 .llseek = seq_lseek,
1903 .release = seq_release,
1904};
1905
1906/*
1907 * Show PCI-E SR-IOV Virtual Function Resource Limits.
1908 */
1909static int resources_show(struct seq_file *seq, void *v)
1910{
1911 struct adapter *adapter = seq->private;
1912 struct vf_resources *vfres = &adapter->params.vfres;
1913
1914 #define S(desc, fmt, var) \
1915 seq_printf(seq, "%-60s " fmt "\n", \
1916 desc " (" #var "):", vfres->var)
1917
1918 S("Virtual Interfaces", "%d", nvi);
1919 S("Egress Queues", "%d", neq);
1920 S("Ethernet Control", "%d", nethctrl);
1921 S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint);
1922 S("Ingress Queues", "%d", niq);
1923 S("Traffic Class", "%d", tc);
1924 S("Port Access Rights Mask", "%#x", pmask);
1925 S("MAC Address Filters", "%d", nexactf);
1926 S("Firmware Command Read Capabilities", "%#x", r_caps);
1927 S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps);
1928
1929 #undef S
1930
1931 return 0;
1932}
1933
1934static int resources_open(struct inode *inode, struct file *file)
1935{
1936 return single_open(file, resources_show, inode->i_private);
1937}
1938
1939static const struct file_operations resources_proc_fops = {
1940 .owner = THIS_MODULE,
1941 .open = resources_open,
1942 .read = seq_read,
1943 .llseek = seq_lseek,
1944 .release = single_release,
1945};
1946
1947/*
1948 * Show Virtual Interfaces.
1949 */
1950static int interfaces_show(struct seq_file *seq, void *v)
1951{
1952 if (v == SEQ_START_TOKEN) {
1953 seq_puts(seq, "Interface Port VIID\n");
1954 } else {
1955 struct adapter *adapter = seq->private;
1956 int pidx = (uintptr_t)v - 2;
1957 struct net_device *dev = adapter->port[pidx];
1958 struct port_info *pi = netdev_priv(dev);
1959
1960 seq_printf(seq, "%9s %4d %#5x\n",
1961 dev->name, pi->port_id, pi->viid);
1962 }
1963 return 0;
1964}
1965
1966static inline void *interfaces_get_idx(struct adapter *adapter, loff_t pos)
1967{
1968 return pos <= adapter->params.nports
1969 ? (void *)(uintptr_t)(pos + 1)
1970 : NULL;
1971}
1972
1973static void *interfaces_start(struct seq_file *seq, loff_t *pos)
1974{
1975 return *pos
1976 ? interfaces_get_idx(seq->private, *pos)
1977 : SEQ_START_TOKEN;
1978}
1979
1980static void *interfaces_next(struct seq_file *seq, void *v, loff_t *pos)
1981{
1982 (*pos)++;
1983 return interfaces_get_idx(seq->private, *pos);
1984}
1985
1986static void interfaces_stop(struct seq_file *seq, void *v)
1987{
1988}
1989
1990static const struct seq_operations interfaces_seq_ops = {
1991 .start = interfaces_start,
1992 .next = interfaces_next,
1993 .stop = interfaces_stop,
1994 .show = interfaces_show
1995};
1996
1997static int interfaces_open(struct inode *inode, struct file *file)
1998{
1999 int res = seq_open(file, &interfaces_seq_ops);
2000
2001 if (res == 0) {
2002 struct seq_file *seq = file->private_data;
2003 seq->private = inode->i_private;
2004 }
2005 return res;
2006}
2007
2008static const struct file_operations interfaces_proc_fops = {
2009 .owner = THIS_MODULE,
2010 .open = interfaces_open,
2011 .read = seq_read,
2012 .llseek = seq_lseek,
2013 .release = seq_release,
2014};
2015
2016/*
2017 * /sys/kernel/debugfs/cxgb4vf/ files list.
2018 */
2019struct cxgb4vf_debugfs_entry {
2020 const char *name; /* name of debugfs node */
f4ae40a6 2021 umode_t mode; /* file system mode */
be839e39
CL		 2022 const struct file_operations *fops;
2023};
2024
2025static struct cxgb4vf_debugfs_entry debugfs_files[] = {
2026 { "sge_qinfo", S_IRUGO, &sge_qinfo_debugfs_fops },
2027 { "sge_qstats", S_IRUGO, &sge_qstats_proc_fops },
2028 { "resources", S_IRUGO, &resources_proc_fops },
2029 { "interfaces", S_IRUGO, &interfaces_proc_fops },
2030};
2031
2032/*
2033 * Module and device initialization and cleanup code.
2034 * ==================================================
2035 */
2036
2037/*
2038 * Set up out /sys/kernel/debug/cxgb4vf sub-nodes. We assume that the
2039 * directory (debugfs_root) has already been set up.
2040 */
d289f864 2041static int setup_debugfs(struct adapter *adapter)
be839e39
CL		 2042{
2043 int i;
2044
843635e0 2045 BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root));
be839e39
CL		 2046
2047 /*
2048 * Debugfs support is best effort.
2049 */
2050 for (i = 0; i < ARRAY_SIZE(debugfs_files); i++)
2051 (void)debugfs_create_file(debugfs_files[i].name,
2052 debugfs_files[i].mode,
2053 adapter->debugfs_root,
2054 (void *)adapter,
2055 debugfs_files[i].fops);
2056
2057 return 0;
2058}
2059
2060/*
2061 * Tear down the /sys/kernel/debug/cxgb4vf sub-nodes created above. We leave
2062 * it to our caller to tear down the directory (debugfs_root).
2063 */
4204875d 2064static void cleanup_debugfs(struct adapter *adapter)
be839e39 2065{
843635e0 2066 BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root));
be839e39
CL		 2067
2068 /*
2069 * Unlike our sister routine cleanup_proc(), we don't need to remove
2070 * individual entries because a call will be made to
2071 * debugfs_remove_recursive(). We just need to clean up any ancillary
2072 * persistent state.
2073 */
2074 /* nothing to do */
2075}
2076
2077/*
2078 * Perform early "adapter" initialization. This is where we discover what
2079 * adapter parameters we're going to be using and initialize basic adapter
2080 * hardware support.
2081 */
d289f864 2082static int adap_init0(struct adapter *adapter)
be839e39
CL		 2083{
2084 struct vf_resources *vfres = &adapter->params.vfres;
2085 struct sge_params *sge_params = &adapter->params.sge;
2086 struct sge *s = &adapter->sge;
2087 unsigned int ethqsets;
2088 int err;
94dace10 2089 u32 param, val = 0;
be839e39
CL		 2090
2091 /*
2092 * Wait for the device to become ready before proceeding ...
2093 */
2094 err = t4vf_wait_dev_ready(adapter);
2095 if (err) {
2096 dev_err(adapter->pdev_dev, "device didn't become ready:"
2097 " err=%d\n", err);
2098 return err;
2099 }
2100
e68e6133
CL		 2101 /*
2102 * Some environments do not properly handle PCIE FLRs -- e.g. in Linux
2103 * 2.6.31 and later we can't call pci_reset_function() in order to
2104 * issue an FLR because of a self- deadlock on the device semaphore.
2105 * Meanwhile, the OS infrastructure doesn't issue FLRs in all the
2106 * cases where they're needed -- for instance, some versions of KVM
2107 * fail to reset "Assigned Devices" when the VM reboots. Therefore we
2108 * use the firmware based reset in order to reset any per function
2109 * state.
2110 */
2111 err = t4vf_fw_reset(adapter);
2112 if (err < 0) {
2113 dev_err(adapter->pdev_dev, "FW reset failed: err=%d\n", err);
2114 return err;
2115 }
2116
622c62b5
SR		 2117 switch (adapter->pdev->device >> 12) {
2118 case CHELSIO_T4:
2119 adapter->chip = CHELSIO_CHIP_CODE(CHELSIO_T4, 0);
2120 break;
2121 case CHELSIO_T5:
2122 adapter->chip = CHELSIO_CHIP_CODE(CHELSIO_T5, 0);
2123 break;
2124 }
2125
be839e39
CL		 2126 /*
2127 * Grab basic operational parameters. These will predominantly have
2128 * been set up by the Physical Function Driver or will be hard coded
2129 * into the adapter. We just have to live with them ... Note that
2130 * we _must_ get our VPD parameters before our SGE parameters because
2131 * we need to know the adapter's core clock from the VPD in order to
2132 * properly decode the SGE Timer Values.
2133 */
2134 err = t4vf_get_dev_params(adapter);
2135 if (err) {
2136 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2137 " device parameters: err=%d\n", err);
2138 return err;
2139 }
2140 err = t4vf_get_vpd_params(adapter);
2141 if (err) {
2142 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2143 " VPD parameters: err=%d\n", err);
2144 return err;
2145 }
2146 err = t4vf_get_sge_params(adapter);
2147 if (err) {
2148 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2149 " SGE parameters: err=%d\n", err);
2150 return err;
2151 }
2152 err = t4vf_get_rss_glb_config(adapter);
2153 if (err) {
2154 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2155 " RSS parameters: err=%d\n", err);
2156 return err;
2157 }
2158 if (adapter->params.rss.mode !=
2159 FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
2160 dev_err(adapter->pdev_dev, "unable to operate with global RSS"
2161 " mode %d\n", adapter->params.rss.mode);
2162 return -EINVAL;
2163 }
2164 err = t4vf_sge_init(adapter);
2165 if (err) {
2166 dev_err(adapter->pdev_dev, "unable to use adapter parameters:"
2167 " err=%d\n", err);
2168 return err;
2169 }
2170
94dace10
VP		 2171 /* If we're running on newer firmware, let it know that we're
2172 * prepared to deal with encapsulated CPL messages. Older
2173 * firmware won't understand this and we'll just get
2174 * unencapsulated messages ...
2175 */
2176 param = FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) |
2177 FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_CPLFW4MSG_ENCAP);
2178 val = 1;
2179 (void) t4vf_set_params(adapter, 1, &param, &val);
2180
be839e39
CL		 2181 /*
2182 * Retrieve our RX interrupt holdoff timer values and counter
2183 * threshold values from the SGE parameters.
2184 */
2185 s->timer_val[0] = core_ticks_to_us(adapter,
2186 TIMERVALUE0_GET(sge_params->sge_timer_value_0_and_1));
2187 s->timer_val[1] = core_ticks_to_us(adapter,
2188 TIMERVALUE1_GET(sge_params->sge_timer_value_0_and_1));
2189 s->timer_val[2] = core_ticks_to_us(adapter,
2190 TIMERVALUE0_GET(sge_params->sge_timer_value_2_and_3));
2191 s->timer_val[3] = core_ticks_to_us(adapter,
2192 TIMERVALUE1_GET(sge_params->sge_timer_value_2_and_3));
2193 s->timer_val[4] = core_ticks_to_us(adapter,
2194 TIMERVALUE0_GET(sge_params->sge_timer_value_4_and_5));
2195 s->timer_val[5] = core_ticks_to_us(adapter,
2196 TIMERVALUE1_GET(sge_params->sge_timer_value_4_and_5));
2197
2198 s->counter_val[0] =
2199 THRESHOLD_0_GET(sge_params->sge_ingress_rx_threshold);
2200 s->counter_val[1] =
2201 THRESHOLD_1_GET(sge_params->sge_ingress_rx_threshold);
2202 s->counter_val[2] =
2203 THRESHOLD_2_GET(sge_params->sge_ingress_rx_threshold);
2204 s->counter_val[3] =
2205 THRESHOLD_3_GET(sge_params->sge_ingress_rx_threshold);
2206
2207 /*
2208 * Grab our Virtual Interface resource allocation, extract the
2209 * features that we're interested in and do a bit of sanity testing on
2210 * what we discover.
2211 */
2212 err = t4vf_get_vfres(adapter);
2213 if (err) {
2214 dev_err(adapter->pdev_dev, "unable to get virtual interface"
2215 " resources: err=%d\n", err);
2216 return err;
2217 }
2218
2219 /*
2220 * The number of "ports" which we support is equal to the number of
2221 * Virtual Interfaces with which we've been provisioned.
2222 */
2223 adapter->params.nports = vfres->nvi;
2224 if (adapter->params.nports > MAX_NPORTS) {
2225 dev_warn(adapter->pdev_dev, "only using %d of %d allowed"
2226 " virtual interfaces\n", MAX_NPORTS,
2227 adapter->params.nports);
2228 adapter->params.nports = MAX_NPORTS;
2229 }
2230
2231 /*
2232 * We need to reserve a number of the ingress queues with Free List
2233 * and Interrupt capabilities for special interrupt purposes (like
2234 * asynchronous firmware messages, or forwarded interrupts if we're
2235 * using MSI). The rest of the FL/Intr-capable ingress queues will be
2236 * matched up one-for-one with Ethernet/Control egress queues in order
2237 * to form "Queue Sets" which will be aportioned between the "ports".
2238 * For each Queue Set, we'll need the ability to allocate two Egress
2239 * Contexts -- one for the Ingress Queue Free List and one for the TX
2240 * Ethernet Queue.
2241 */
2242 ethqsets = vfres->niqflint - INGQ_EXTRAS;
2243 if (vfres->nethctrl != ethqsets) {
2244 dev_warn(adapter->pdev_dev, "unequal number of [available]"
2245 " ingress/egress queues (%d/%d); using minimum for"
2246 " number of Queue Sets\n", ethqsets, vfres->nethctrl);
2247 ethqsets = min(vfres->nethctrl, ethqsets);
2248 }
2249 if (vfres->neq < ethqsets*2) {
2250 dev_warn(adapter->pdev_dev, "Not enough Egress Contexts (%d)"
2251 " to support Queue Sets (%d); reducing allowed Queue"
2252 " Sets\n", vfres->neq, ethqsets);
2253 ethqsets = vfres->neq/2;
2254 }
2255 if (ethqsets > MAX_ETH_QSETS) {
2256 dev_warn(adapter->pdev_dev, "only using %d of %d allowed Queue"
2257 " Sets\n", MAX_ETH_QSETS, adapter->sge.max_ethqsets);
2258 ethqsets = MAX_ETH_QSETS;
2259 }
2260 if (vfres->niq != 0 || vfres->neq > ethqsets*2) {
2261 dev_warn(adapter->pdev_dev, "unused resources niq/neq (%d/%d)"
2262 " ignored\n", vfres->niq, vfres->neq - ethqsets*2);
2263 }
2264 adapter->sge.max_ethqsets = ethqsets;
2265
2266 /*
2267 * Check for various parameter sanity issues. Most checks simply
2268 * result in us using fewer resources than our provissioning but we
2269 * do need at least one "port" with which to work ...
2270 */
2271 if (adapter->sge.max_ethqsets < adapter->params.nports) {
2272 dev_warn(adapter->pdev_dev, "only using %d of %d available"
2273 " virtual interfaces (too few Queue Sets)\n",
2274 adapter->sge.max_ethqsets, adapter->params.nports);
2275 adapter->params.nports = adapter->sge.max_ethqsets;
2276 }
2277 if (adapter->params.nports == 0) {
2278 dev_err(adapter->pdev_dev, "no virtual interfaces configured/"
2279 "usable!\n");
2280 return -EINVAL;
2281 }
2282 return 0;
2283}
2284
2285static inline void init_rspq(struct sge_rspq *rspq, u8 timer_idx,
2286 u8 pkt_cnt_idx, unsigned int size,
2287 unsigned int iqe_size)
2288{
2289 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
2290 (pkt_cnt_idx < SGE_NCOUNTERS ? QINTR_CNT_EN : 0));
2291 rspq->pktcnt_idx = (pkt_cnt_idx < SGE_NCOUNTERS
2292 ? pkt_cnt_idx
2293 : 0);
2294 rspq->iqe_len = iqe_size;
2295 rspq->size = size;
2296}
2297
2298/*
2299 * Perform default configuration of DMA queues depending on the number and
2300 * type of ports we found and the number of available CPUs. Most settings can
2301 * be modified by the admin via ethtool and cxgbtool prior to the adapter
2302 * being brought up for the first time.
2303 */
d289f864 2304static void cfg_queues(struct adapter *adapter)
be839e39
CL		 2305{
2306 struct sge *s = &adapter->sge;
2307 int q10g, n10g, qidx, pidx, qs;
c710245c 2308 size_t iqe_size;
be839e39
CL		 2309
2310 /*
2311 * We should not be called till we know how many Queue Sets we can
2312 * support. In particular, this means that we need to know what kind
2313 * of interrupts we'll be using ...
2314 */
2315 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0);
2316
2317 /*
2318 * Count the number of 10GbE Virtual Interfaces that we have.
2319 */
2320 n10g = 0;
2321 for_each_port(adapter, pidx)
2322 n10g += is_10g_port(&adap2pinfo(adapter, pidx)->link_cfg);
2323
2324 /*
2325 * We default to 1 queue per non-10G port and up to # of cores queues
2326 * per 10G port.
2327 */
2328 if (n10g == 0)
2329 q10g = 0;
2330 else {
2331 int n1g = (adapter->params.nports - n10g);
2332 q10g = (adapter->sge.max_ethqsets - n1g) / n10g;
2333 if (q10g > num_online_cpus())
2334 q10g = num_online_cpus();
2335 }
2336
2337 /*
2338 * Allocate the "Queue Sets" to the various Virtual Interfaces.
2339 * The layout will be established in setup_sge_queues() when the
2340 * adapter is brough up for the first time.
2341 */
2342 qidx = 0;
2343 for_each_port(adapter, pidx) {
2344 struct port_info *pi = adap2pinfo(adapter, pidx);
2345
2346 pi->first_qset = qidx;
2347 pi->nqsets = is_10g_port(&pi->link_cfg) ? q10g : 1;
2348 qidx += pi->nqsets;
2349 }
2350 s->ethqsets = qidx;
2351
c710245c
CL		 2352 /*
2353 * The Ingress Queue Entry Size for our various Response Queues needs
2354 * to be big enough to accommodate the largest message we can receive
2355 * from the chip/firmware; which is 64 bytes ...
2356 */
2357 iqe_size = 64;
2358
be839e39
CL		 2359 /*
2360 * Set up default Queue Set parameters ... Start off with the
2361 * shortest interrupt holdoff timer.
2362 */
2363 for (qs = 0; qs < s->max_ethqsets; qs++) {
2364 struct sge_eth_rxq *rxq = &s->ethrxq[qs];
2365 struct sge_eth_txq *txq = &s->ethtxq[qs];
2366
c710245c 2367 init_rspq(&rxq->rspq, 0, 0, 1024, iqe_size);
be839e39
CL		 2368 rxq->fl.size = 72;
2369 txq->q.size = 1024;
2370 }
2371
2372 /*
2373 * The firmware event queue is used for link state changes and
2374 * notifications of TX DMA completions.
2375 */
c710245c 2376 init_rspq(&s->fw_evtq, SGE_TIMER_RSTRT_CNTR, 0, 512, iqe_size);
be839e39
CL		 2377
2378 /*
2379 * The forwarded interrupt queue is used when we're in MSI interrupt
2380 * mode. In this mode all interrupts associated with RX queues will
2381 * be forwarded to a single queue which we'll associate with our MSI
2382 * interrupt vector. The messages dropped in the forwarded interrupt
2383 * queue will indicate which ingress queue needs servicing ... This
2384 * queue needs to be large enough to accommodate all of the ingress
2385 * queues which are forwarding their interrupt (+1 to prevent the PIDX
2386 * from equalling the CIDX if every ingress queue has an outstanding
2387 * interrupt). The queue doesn't need to be any larger because no
2388 * ingress queue will ever have more than one outstanding interrupt at
2389 * any time ...
2390 */
2391 init_rspq(&s->intrq, SGE_TIMER_RSTRT_CNTR, 0, MSIX_ENTRIES + 1,
c710245c 2392 iqe_size);
be839e39
CL		 2393}
2394
2395/*
2396 * Reduce the number of Ethernet queues across all ports to at most n.
2397 * n provides at least one queue per port.
2398 */
d289f864 2399static void reduce_ethqs(struct adapter *adapter, int n)
be839e39
CL		 2400{
2401 int i;
2402 struct port_info *pi;
2403
2404 /*
2405 * While we have too many active Ether Queue Sets, interate across the
2406 * "ports" and reduce their individual Queue Set allocations.
2407 */
2408 BUG_ON(n < adapter->params.nports);
2409 while (n < adapter->sge.ethqsets)
2410 for_each_port(adapter, i) {
2411 pi = adap2pinfo(adapter, i);
2412 if (pi->nqsets > 1) {
2413 pi->nqsets--;
2414 adapter->sge.ethqsets--;
2415 if (adapter->sge.ethqsets <= n)
2416 break;
2417 }
2418 }
2419
2420 /*
2421 * Reassign the starting Queue Sets for each of the "ports" ...
2422 */
2423 n = 0;
2424 for_each_port(adapter, i) {
2425 pi = adap2pinfo(adapter, i);
2426 pi->first_qset = n;
2427 n += pi->nqsets;
2428 }
2429}
2430
2431/*
2432 * We need to grab enough MSI-X vectors to cover our interrupt needs. Ideally
2433 * we get a separate MSI-X vector for every "Queue Set" plus any extras we
2434 * need. Minimally we need one for every Virtual Interface plus those needed
2435 * for our "extras". Note that this process may lower the maximum number of
2436 * allowed Queue Sets ...
2437 */
d289f864 2438static int enable_msix(struct adapter *adapter)
be839e39
CL		 2439{
2440 int i, err, want, need;
2441 struct msix_entry entries[MSIX_ENTRIES];
2442 struct sge *s = &adapter->sge;
2443
2444 for (i = 0; i < MSIX_ENTRIES; ++i)
2445 entries[i].entry = i;
2446
2447 /*
2448 * We _want_ enough MSI-X interrupts to cover all of our "Queue Sets"
2449 * plus those needed for our "extras" (for example, the firmware
2450 * message queue). We _need_ at least one "Queue Set" per Virtual
2451 * Interface plus those needed for our "extras". So now we get to see
2452 * if the song is right ...
2453 */
2454 want = s->max_ethqsets + MSIX_EXTRAS;
2455 need = adapter->params.nports + MSIX_EXTRAS;
2456 while ((err = pci_enable_msix(adapter->pdev, entries, want)) >= need)
2457 want = err;
2458
2459 if (err == 0) {
2460 int nqsets = want - MSIX_EXTRAS;
2461 if (nqsets < s->max_ethqsets) {
2462 dev_warn(adapter->pdev_dev, "only enough MSI-X vectors"
2463 " for %d Queue Sets\n", nqsets);
2464 s->max_ethqsets = nqsets;
2465 if (nqsets < s->ethqsets)
2466 reduce_ethqs(adapter, nqsets);
2467 }
2468 for (i = 0; i < want; ++i)
2469 adapter->msix_info[i].vec = entries[i].vector;
2470 } else if (err > 0) {
2471 pci_disable_msix(adapter->pdev);
2472 dev_info(adapter->pdev_dev, "only %d MSI-X vectors left,"
2473 " not using MSI-X\n", err);
2474 }
2475 return err;
2476}
2477
be839e39
CL		 2478static const struct net_device_ops cxgb4vf_netdev_ops = {
2479 .ndo_open = cxgb4vf_open,
2480 .ndo_stop = cxgb4vf_stop,
2481 .ndo_start_xmit = t4vf_eth_xmit,
2482 .ndo_get_stats = cxgb4vf_get_stats,
2483 .ndo_set_rx_mode = cxgb4vf_set_rxmode,
2484 .ndo_set_mac_address = cxgb4vf_set_mac_addr,
be839e39
CL		 2485 .ndo_validate_addr = eth_validate_addr,
2486 .ndo_do_ioctl = cxgb4vf_do_ioctl,
2487 .ndo_change_mtu = cxgb4vf_change_mtu,
87737663
JP		 2488 .ndo_fix_features = cxgb4vf_fix_features,
2489 .ndo_set_features = cxgb4vf_set_features,
be839e39
CL		 2490#ifdef CONFIG_NET_POLL_CONTROLLER
2491 .ndo_poll_controller = cxgb4vf_poll_controller,
2492#endif
2493};
be839e39
CL		 2494
2495/*
2496 * "Probe" a device: initialize a device and construct all kernel and driver
2497 * state needed to manage the device. This routine is called "init_one" in
2498 * the PF Driver ...
2499 */
d289f864 2500static int cxgb4vf_pci_probe(struct pci_dev *pdev,
1dd06ae8 2501 const struct pci_device_id *ent)
be839e39 2502{
be839e39
CL		 2503 int pci_using_dac;
2504 int err, pidx;
2505 unsigned int pmask;
2506 struct adapter *adapter;
2507 struct port_info *pi;
2508 struct net_device *netdev;
2509
be839e39
CL		 2510 /*
2511 * Print our driver banner the first time we're called to initialize a
2512 * device.
2513 */
428ac43f 2514 pr_info_once("%s - version %s\n", DRV_DESC, DRV_VERSION);
be839e39
CL		 2515
2516 /*
7a0c2029 2517 * Initialize generic PCI device state.
be839e39 2518 */
7a0c2029 2519 err = pci_enable_device(pdev);
be839e39 2520 if (err) {
7a0c2029 2521 dev_err(&pdev->dev, "cannot enable PCI device\n");
be839e39
CL		 2522 return err;
2523 }
2524
2525 /*
7a0c2029
KV		 2526 * Reserve PCI resources for the device. If we can't get them some
2527 * other driver may have already claimed the device ...
be839e39 2528 */
7a0c2029 2529 err = pci_request_regions(pdev, KBUILD_MODNAME);
be839e39 2530 if (err) {
7a0c2029
KV		 2531 dev_err(&pdev->dev, "cannot obtain PCI resources\n");
2532 goto err_disable_device;
be839e39
CL		 2533 }
2534
2535 /*
2536 * Set up our DMA mask: try for 64-bit address masking first and
2537 * fall back to 32-bit if we can't get 64 bits ...
2538 */
2539 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2540 if (err == 0) {
2541 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
2542 if (err) {
2543 dev_err(&pdev->dev, "unable to obtain 64-bit DMA for"
2544 " coherent allocations\n");
7a0c2029 2545 goto err_release_regions;
be839e39
CL		 2546 }
2547 pci_using_dac = 1;
2548 } else {
2549 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2550 if (err != 0) {
2551 dev_err(&pdev->dev, "no usable DMA configuration\n");
7a0c2029 2552 goto err_release_regions;
be839e39
CL		 2553 }
2554 pci_using_dac = 0;
2555 }
2556
2557 /*
2558 * Enable bus mastering for the device ...
2559 */
2560 pci_set_master(pdev);
2561
2562 /*
2563 * Allocate our adapter data structure and attach it to the device.
2564 */
2565 adapter = kzalloc(sizeof(*adapter), GFP_KERNEL);
2566 if (!adapter) {
2567 err = -ENOMEM;
7a0c2029 2568 goto err_release_regions;
be839e39
CL		 2569 }
2570 pci_set_drvdata(pdev, adapter);
2571 adapter->pdev = pdev;
2572 adapter->pdev_dev = &pdev->dev;
2573
2574 /*
2575 * Initialize SMP data synchronization resources.
2576 */
2577 spin_lock_init(&adapter->stats_lock);
2578
2579 /*
2580 * Map our I/O registers in BAR0.
2581 */
2582 adapter->regs = pci_ioremap_bar(pdev, 0);
2583 if (!adapter->regs) {
2584 dev_err(&pdev->dev, "cannot map device registers\n");
2585 err = -ENOMEM;
2586 goto err_free_adapter;
2587 }
2588
2589 /*
2590 * Initialize adapter level features.
2591 */
2592 adapter->name = pci_name(pdev);
2593 adapter->msg_enable = dflt_msg_enable;
2594 err = adap_init0(adapter);
2595 if (err)
2596 goto err_unmap_bar;
2597
2598 /*
2599 * Allocate our "adapter ports" and stitch everything together.
2600 */
2601 pmask = adapter->params.vfres.pmask;
2602 for_each_port(adapter, pidx) {
2603 int port_id, viid;
2604
2605 /*
2606 * We simplistically allocate our virtual interfaces
2607 * sequentially across the port numbers to which we have
2608 * access rights. This should be configurable in some manner
2609 * ...
2610 */
2611 if (pmask == 0)
2612 break;
2613 port_id = ffs(pmask) - 1;
2614 pmask &= ~(1 << port_id);
2615 viid = t4vf_alloc_vi(adapter, port_id);
2616 if (viid < 0) {
2617 dev_err(&pdev->dev, "cannot allocate VI for port %d:"
2618 " err=%d\n", port_id, viid);
2619 err = viid;
2620 goto err_free_dev;
2621 }
2622
2623 /*
2624 * Allocate our network device and stitch things together.
2625 */
2626 netdev = alloc_etherdev_mq(sizeof(struct port_info),
2627 MAX_PORT_QSETS);
2628 if (netdev == NULL) {
be839e39
CL		 2629 t4vf_free_vi(adapter, viid);
2630 err = -ENOMEM;
2631 goto err_free_dev;
2632 }
2633 adapter->port[pidx] = netdev;
2634 SET_NETDEV_DEV(netdev, &pdev->dev);
2635 pi = netdev_priv(netdev);
2636 pi->adapter = adapter;
2637 pi->pidx = pidx;
2638 pi->port_id = port_id;
2639 pi->viid = viid;
2640
2641 /*
2642 * Initialize the starting state of our "port" and register
2643 * it.
2644 */
2645 pi->xact_addr_filt = -1;
be839e39 2646 netif_carrier_off(netdev);
be839e39
CL		 2647 netdev->irq = pdev->irq;
2648
2ed28baa
MM		 2649 netdev->hw_features = NETIF_F_SG | TSO_FLAGS |
2650 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
f646968f 2651 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_RXCSUM;
2ed28baa
MM		 2652 netdev->vlan_features = NETIF_F_SG | TSO_FLAGS |
2653 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2654 NETIF_F_HIGHDMA;
f646968f
PM		 2655 netdev->features = netdev->hw_features |
2656 NETIF_F_HW_VLAN_CTAG_TX;
be839e39
CL		 2657 if (pci_using_dac)
2658 netdev->features |= NETIF_F_HIGHDMA;
be839e39 2659
01789349
JP		 2660 netdev->priv_flags |= IFF_UNICAST_FLT;
2661
be839e39 2662 netdev->netdev_ops = &cxgb4vf_netdev_ops;
be839e39
CL		 2663 SET_ETHTOOL_OPS(netdev, &cxgb4vf_ethtool_ops);
2664
2665 /*
2666 * Initialize the hardware/software state for the port.
2667 */
2668 err = t4vf_port_init(adapter, pidx);
2669 if (err) {
2670 dev_err(&pdev->dev, "cannot initialize port %d\n",
2671 pidx);
2672 goto err_free_dev;
2673 }
2674 }
2675
2676 /*
2677 * The "card" is now ready to go. If any errors occur during device
2678 * registration we do not fail the whole "card" but rather proceed
2679 * only with the ports we manage to register successfully. However we
2680 * must register at least one net device.
2681 */
2682 for_each_port(adapter, pidx) {
2683 netdev = adapter->port[pidx];
2684 if (netdev == NULL)
2685 continue;
2686
2687 err = register_netdev(netdev);
2688 if (err) {
2689 dev_warn(&pdev->dev, "cannot register net device %s,"
2690 " skipping\n", netdev->name);
2691 continue;
2692 }
2693
2694 set_bit(pidx, &adapter->registered_device_map);
2695 }
2696 if (adapter->registered_device_map == 0) {
2697 dev_err(&pdev->dev, "could not register any net devices\n");
2698 goto err_free_dev;
2699 }
2700
2701 /*
2702 * Set up our debugfs entries.
2703 */
843635e0 2704 if (!IS_ERR_OR_NULL(cxgb4vf_debugfs_root)) {
be839e39
CL		 2705 adapter->debugfs_root =
2706 debugfs_create_dir(pci_name(pdev),
2707 cxgb4vf_debugfs_root);
843635e0 2708 if (IS_ERR_OR_NULL(adapter->debugfs_root))
be839e39
CL		 2709 dev_warn(&pdev->dev, "could not create debugfs"
2710 " directory");
2711 else
2712 setup_debugfs(adapter);
2713 }
2714
2715 /*
2716 * See what interrupts we'll be using. If we've been configured to
2717 * use MSI-X interrupts, try to enable them but fall back to using
2718 * MSI interrupts if we can't enable MSI-X interrupts. If we can't
2719 * get MSI interrupts we bail with the error.
2720 */
2721 if (msi == MSI_MSIX && enable_msix(adapter) == 0)
2722 adapter->flags |= USING_MSIX;
2723 else {
2724 err = pci_enable_msi(pdev);
2725 if (err) {
2726 dev_err(&pdev->dev, "Unable to allocate %s interrupts;"
2727 " err=%d\n",
2728 msi == MSI_MSIX ? "MSI-X or MSI" : "MSI", err);
2729 goto err_free_debugfs;
2730 }
2731 adapter->flags |= USING_MSI;
2732 }
2733
2734 /*
2735 * Now that we know how many "ports" we have and what their types are,
2736 * and how many Queue Sets we can support, we can configure our queue
2737 * resources.
2738 */
2739 cfg_queues(adapter);
2740
2741 /*
25985edc 2742 * Print a short notice on the existence and configuration of the new
be839e39
CL		 2743 * VF network device ...
2744 */
2745 for_each_port(adapter, pidx) {
2746 dev_info(adapter->pdev_dev, "%s: Chelsio VF NIC PCIe %s\n",
2747 adapter->port[pidx]->name,
2748 (adapter->flags & USING_MSIX) ? "MSI-X" :
2749 (adapter->flags & USING_MSI) ? "MSI" : "");
2750 }
2751
2752 /*
2753 * Return success!
2754 */
2755 return 0;
2756
2757 /*
2758 * Error recovery and exit code. Unwind state that's been created
2759 * so far and return the error.
2760 */
2761
2762err_free_debugfs:
843635e0 2763 if (!IS_ERR_OR_NULL(adapter->debugfs_root)) {
be839e39
CL		 2764 cleanup_debugfs(adapter);
2765 debugfs_remove_recursive(adapter->debugfs_root);
2766 }
2767
2768err_free_dev:
2769 for_each_port(adapter, pidx) {
2770 netdev = adapter->port[pidx];
2771 if (netdev == NULL)
2772 continue;
2773 pi = netdev_priv(netdev);
2774 t4vf_free_vi(adapter, pi->viid);
2775 if (test_bit(pidx, &adapter->registered_device_map))
2776 unregister_netdev(netdev);
2777 free_netdev(netdev);
2778 }
2779
2780err_unmap_bar:
2781 iounmap(adapter->regs);
2782
2783err_free_adapter:
2784 kfree(adapter);
be839e39 2785
be839e39
CL		 2786err_release_regions:
2787 pci_release_regions(pdev);
7a0c2029
KV		 2788 pci_clear_master(pdev);
2789
2790err_disable_device:
2791 pci_disable_device(pdev);
be839e39 2792
be839e39
CL		 2793 return err;
2794}
2795
2796/*
2797 * "Remove" a device: tear down all kernel and driver state created in the
2798 * "probe" routine and quiesce the device (disable interrupts, etc.). (Note
2799 * that this is called "remove_one" in the PF Driver.)
2800 */
d289f864 2801static void cxgb4vf_pci_remove(struct pci_dev *pdev)
be839e39
CL		 2802{
2803 struct adapter *adapter = pci_get_drvdata(pdev);
2804
2805 /*
2806 * Tear down driver state associated with device.
2807 */
2808 if (adapter) {
2809 int pidx;
2810
2811 /*
2812 * Stop all of our activity. Unregister network port,
2813 * disable interrupts, etc.
2814 */
2815 for_each_port(adapter, pidx)
2816 if (test_bit(pidx, &adapter->registered_device_map))
2817 unregister_netdev(adapter->port[pidx]);
2818 t4vf_sge_stop(adapter);
2819 if (adapter->flags & USING_MSIX) {
2820 pci_disable_msix(adapter->pdev);
2821 adapter->flags &= ~USING_MSIX;
2822 } else if (adapter->flags & USING_MSI) {
2823 pci_disable_msi(adapter->pdev);
2824 adapter->flags &= ~USING_MSI;
2825 }
2826
2827 /*
2828 * Tear down our debugfs entries.
2829 */
843635e0 2830 if (!IS_ERR_OR_NULL(adapter->debugfs_root)) {
be839e39
CL		 2831 cleanup_debugfs(adapter);
2832 debugfs_remove_recursive(adapter->debugfs_root);
2833 }
2834
2835 /*
2836 * Free all of the various resources which we've acquired ...
2837 */
2838 t4vf_free_sge_resources(adapter);
2839 for_each_port(adapter, pidx) {
2840 struct net_device *netdev = adapter->port[pidx];
2841 struct port_info *pi;
2842
2843 if (netdev == NULL)
2844 continue;
2845
2846 pi = netdev_priv(netdev);
2847 t4vf_free_vi(adapter, pi->viid);
2848 free_netdev(netdev);
2849 }
2850 iounmap(adapter->regs);
2851 kfree(adapter);
be839e39
CL		 2852 }
2853
2854 /*
2855 * Disable the device and release its PCI resources.
2856 */
2857 pci_disable_device(pdev);
2858 pci_clear_master(pdev);
2859 pci_release_regions(pdev);
2860}
2861
7e9c2629
CL		 2862/*
2863 * "Shutdown" quiesce the device, stopping Ingress Packet and Interrupt
2864 * delivery.
2865 */
d289f864 2866static void cxgb4vf_pci_shutdown(struct pci_dev *pdev)
7e9c2629
CL		 2867{
2868 struct adapter *adapter;
2869 int pidx;
2870
2871 adapter = pci_get_drvdata(pdev);
2872 if (!adapter)
2873 return;
2874
2875 /*
2876 * Disable all Virtual Interfaces. This will shut down the
2877 * delivery of all ingress packets into the chip for these
2878 * Virtual Interfaces.
2879 */
2880 for_each_port(adapter, pidx) {
2881 struct net_device *netdev;
2882 struct port_info *pi;
2883
2884 if (!test_bit(pidx, &adapter->registered_device_map))
2885 continue;
2886
2887 netdev = adapter->port[pidx];
2888 if (!netdev)
2889 continue;
2890
2891 pi = netdev_priv(netdev);
2892 t4vf_enable_vi(adapter, pi->viid, false, false);
2893 }
2894
2895 /*
2896 * Free up all Queues which will prevent further DMA and
2897 * Interrupts allowing various internal pathways to drain.
2898 */
2899 t4vf_free_sge_resources(adapter);
2900}
2901
be839e39
CL		 2902/*
2903 * PCI Device registration data structures.
2904 */
2905#define CH_DEVICE(devid, idx) \
2906 { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
2907
1eb850c7 2908static DEFINE_PCI_DEVICE_TABLE(cxgb4vf_pci_tbl) = {
be839e39
CL		 2909 CH_DEVICE(0xb000, 0), /* PE10K FPGA */
2910 CH_DEVICE(0x4800, 0), /* T440-dbg */
2911 CH_DEVICE(0x4801, 0), /* T420-cr */
2912 CH_DEVICE(0x4802, 0), /* T422-cr */
8b6edf87
CL		 2913 CH_DEVICE(0x4803, 0), /* T440-cr */
2914 CH_DEVICE(0x4804, 0), /* T420-bch */
2915 CH_DEVICE(0x4805, 0), /* T440-bch */
2916 CH_DEVICE(0x4806, 0), /* T460-ch */
2917 CH_DEVICE(0x4807, 0), /* T420-so */
2918 CH_DEVICE(0x4808, 0), /* T420-cx */
2919 CH_DEVICE(0x4809, 0), /* T420-bt */
2920 CH_DEVICE(0x480a, 0), /* T404-bt */
79421b4e
VP		 2921 CH_DEVICE(0x480d, 0), /* T480-cr */
2922 CH_DEVICE(0x480e, 0), /* T440-lp-cr */
622c62b5
SR		 2923 CH_DEVICE(0x5800, 0), /* T580-dbg */
2924 CH_DEVICE(0x5801, 0), /* T520-cr */
2925 CH_DEVICE(0x5802, 0), /* T522-cr */
2926 CH_DEVICE(0x5803, 0), /* T540-cr */
2927 CH_DEVICE(0x5804, 0), /* T520-bch */
2928 CH_DEVICE(0x5805, 0), /* T540-bch */
2929 CH_DEVICE(0x5806, 0), /* T540-ch */
2930 CH_DEVICE(0x5807, 0), /* T520-so */
2931 CH_DEVICE(0x5808, 0), /* T520-cx */
2932 CH_DEVICE(0x5809, 0), /* T520-bt */
2933 CH_DEVICE(0x580a, 0), /* T504-bt */
2934 CH_DEVICE(0x580b, 0), /* T520-sr */
2935 CH_DEVICE(0x580c, 0), /* T504-bt */
2936 CH_DEVICE(0x580d, 0), /* T580-cr */
2937 CH_DEVICE(0x580e, 0), /* T540-lp-cr */
2938 CH_DEVICE(0x580f, 0), /* Amsterdam */
2939 CH_DEVICE(0x5810, 0), /* T580-lp-cr */
2940 CH_DEVICE(0x5811, 0), /* T520-lp-cr */
2941 CH_DEVICE(0x5812, 0), /* T560-cr */
2942 CH_DEVICE(0x5813, 0), /* T580-cr */
be839e39
CL		 2943 { 0, }
2944};
2945
2946MODULE_DESCRIPTION(DRV_DESC);
2947MODULE_AUTHOR("Chelsio Communications");
2948MODULE_LICENSE("Dual BSD/GPL");
2949MODULE_VERSION(DRV_VERSION);
2950MODULE_DEVICE_TABLE(pci, cxgb4vf_pci_tbl);
2951
2952static struct pci_driver cxgb4vf_driver = {
2953 .name = KBUILD_MODNAME,
2954 .id_table = cxgb4vf_pci_tbl,
2955 .probe = cxgb4vf_pci_probe,
d289f864
BP		 2956 .remove = cxgb4vf_pci_remove,
2957 .shutdown = cxgb4vf_pci_shutdown,
be839e39
CL		 2958};
2959
2960/*
2961 * Initialize global driver state.
2962 */
2963static int __init cxgb4vf_module_init(void)
2964{
2965 int ret;
2966
bb14a1af
CL		 2967 /*
2968 * Vet our module parameters.
2969 */
2970 if (msi != MSI_MSIX && msi != MSI_MSI) {
428ac43f
JP		 2971 pr_warn("bad module parameter msi=%d; must be %d (MSI-X or MSI) or %d (MSI)\n",
2972 msi, MSI_MSIX, MSI_MSI);
bb14a1af
CL		 2973 return -EINVAL;
2974 }
2975
be839e39
CL		 2976 /* Debugfs support is optional, just warn if this fails */
2977 cxgb4vf_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
843635e0 2978 if (IS_ERR_OR_NULL(cxgb4vf_debugfs_root))
428ac43f 2979 pr_warn("could not create debugfs entry, continuing\n");
be839e39
CL		 2980
2981 ret = pci_register_driver(&cxgb4vf_driver);
843635e0 2982 if (ret < 0 && !IS_ERR_OR_NULL(cxgb4vf_debugfs_root))
be839e39
CL		 2983 debugfs_remove(cxgb4vf_debugfs_root);
2984 return ret;
2985}
2986
2987/*
2988 * Tear down global driver state.
2989 */
2990static void __exit cxgb4vf_module_exit(void)
2991{
2992 pci_unregister_driver(&cxgb4vf_driver);
2993 debugfs_remove(cxgb4vf_debugfs_root);
2994}
2995
2996module_init(cxgb4vf_module_init);
2997module_exit(cxgb4vf_module_exit);
Linux kernel - Deliverables
This page took 0.477317 seconds and 5 git commands to generate.