mlx4_en: Use netif_set_real_num_{rx, tx}_queues()
[linux-2.6/btrfs-unstable.git] / drivers / net / cxgb4vf / cxgb4vf_main.c
blob555ecc5a2e939b25028ac6a61cf2792da379caa7
1 /*
2 * This file is part of the Chelsio T4 PCI-E SR-IOV Virtual Function Ethernet
3 * driver for Linux.
5 * Copyright (c) 2009-2010 Chelsio Communications, Inc. All rights reserved.
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:
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer.
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.
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.
36 #include <linux/version.h>
37 #include <linux/module.h>
38 #include <linux/moduleparam.h>
39 #include <linux/init.h>
40 #include <linux/pci.h>
41 #include <linux/dma-mapping.h>
42 #include <linux/netdevice.h>
43 #include <linux/etherdevice.h>
44 #include <linux/debugfs.h>
45 #include <linux/ethtool.h>
47 #include "t4vf_common.h"
48 #include "t4vf_defs.h"
50 #include "../cxgb4/t4_regs.h"
51 #include "../cxgb4/t4_msg.h"
54 * Generic information about the driver.
56 #define DRV_VERSION "1.0.0"
57 #define DRV_DESC "Chelsio T4 Virtual Function (VF) Network Driver"
60 * Module Parameters.
61 * ==================
65 * Default ethtool "message level" for adapters.
67 #define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \
68 NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\
69 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR)
71 static int dflt_msg_enable = DFLT_MSG_ENABLE;
73 module_param(dflt_msg_enable, int, 0644);
74 MODULE_PARM_DESC(dflt_msg_enable,
75 "default adapter ethtool message level bitmap");
78 * The driver uses the best interrupt scheme available on a platform in the
79 * order MSI-X then MSI. This parameter determines which of these schemes the
80 * driver may consider as follows:
82 * msi = 2: choose from among MSI-X and MSI
83 * msi = 1: only consider MSI interrupts
85 * Note that unlike the Physical Function driver, this Virtual Function driver
86 * does _not_ support legacy INTx interrupts (this limitation is mandated by
87 * the PCI-E SR-IOV standard).
89 #define MSI_MSIX 2
90 #define MSI_MSI 1
91 #define MSI_DEFAULT MSI_MSIX
93 static int msi = MSI_DEFAULT;
95 module_param(msi, int, 0644);
96 MODULE_PARM_DESC(msi, "whether to use MSI-X or MSI");
99 * Fundamental constants.
100 * ======================
103 enum {
104 MAX_TXQ_ENTRIES = 16384,
105 MAX_RSPQ_ENTRIES = 16384,
106 MAX_RX_BUFFERS = 16384,
108 MIN_TXQ_ENTRIES = 32,
109 MIN_RSPQ_ENTRIES = 128,
110 MIN_FL_ENTRIES = 16,
113 * For purposes of manipulating the Free List size we need to
114 * recognize that Free Lists are actually Egress Queues (the host
115 * produces free buffers which the hardware consumes), Egress Queues
116 * indices are all in units of Egress Context Units bytes, and free
117 * list entries are 64-bit PCI DMA addresses. And since the state of
118 * the Producer Index == the Consumer Index implies an EMPTY list, we
119 * always have at least one Egress Unit's worth of Free List entries
120 * unused. See sge.c for more details ...
122 EQ_UNIT = SGE_EQ_IDXSIZE,
123 FL_PER_EQ_UNIT = EQ_UNIT / sizeof(__be64),
124 MIN_FL_RESID = FL_PER_EQ_UNIT,
128 * Global driver state.
129 * ====================
132 static struct dentry *cxgb4vf_debugfs_root;
135 * OS "Callback" functions.
136 * ========================
140 * The link status has changed on the indicated "port" (Virtual Interface).
142 void t4vf_os_link_changed(struct adapter *adapter, int pidx, int link_ok)
144 struct net_device *dev = adapter->port[pidx];
147 * If the port is disabled or the current recorded "link up"
148 * status matches the new status, just return.
150 if (!netif_running(dev) || link_ok == netif_carrier_ok(dev))
151 return;
154 * Tell the OS that the link status has changed and print a short
155 * informative message on the console about the event.
157 if (link_ok) {
158 const char *s;
159 const char *fc;
160 const struct port_info *pi = netdev_priv(dev);
162 netif_carrier_on(dev);
164 switch (pi->link_cfg.speed) {
165 case SPEED_10000:
166 s = "10Gbps";
167 break;
169 case SPEED_1000:
170 s = "1000Mbps";
171 break;
173 case SPEED_100:
174 s = "100Mbps";
175 break;
177 default:
178 s = "unknown";
179 break;
182 switch (pi->link_cfg.fc) {
183 case PAUSE_RX:
184 fc = "RX";
185 break;
187 case PAUSE_TX:
188 fc = "TX";
189 break;
191 case PAUSE_RX|PAUSE_TX:
192 fc = "RX/TX";
193 break;
195 default:
196 fc = "no";
197 break;
200 printk(KERN_INFO "%s: link up, %s, full-duplex, %s PAUSE\n",
201 dev->name, s, fc);
202 } else {
203 netif_carrier_off(dev);
204 printk(KERN_INFO "%s: link down\n", dev->name);
209 * Net device operations.
210 * ======================
214 * Record our new VLAN Group and enable/disable hardware VLAN Tag extraction
215 * based on whether the specified VLAN Group pointer is NULL or not.
217 static void cxgb4vf_vlan_rx_register(struct net_device *dev,
218 struct vlan_group *grp)
220 struct port_info *pi = netdev_priv(dev);
222 pi->vlan_grp = grp;
223 t4vf_set_rxmode(pi->adapter, pi->viid, -1, -1, -1, -1, grp != NULL, 0);
227 * Perform the MAC and PHY actions needed to enable a "port" (Virtual
228 * Interface).
230 static int link_start(struct net_device *dev)
232 int ret;
233 struct port_info *pi = netdev_priv(dev);
236 * We do not set address filters and promiscuity here, the stack does
237 * that step explicitly.
239 ret = t4vf_set_rxmode(pi->adapter, pi->viid, dev->mtu, -1, -1, -1, -1,
240 true);
241 if (ret == 0) {
242 ret = t4vf_change_mac(pi->adapter, pi->viid,
243 pi->xact_addr_filt, dev->dev_addr, true);
244 if (ret >= 0) {
245 pi->xact_addr_filt = ret;
246 ret = 0;
251 * We don't need to actually "start the link" itself since the
252 * firmware will do that for us when the first Virtual Interface
253 * is enabled on a port.
255 if (ret == 0)
256 ret = t4vf_enable_vi(pi->adapter, pi->viid, true, true);
257 return ret;
261 * Name the MSI-X interrupts.
263 static void name_msix_vecs(struct adapter *adapter)
265 int namelen = sizeof(adapter->msix_info[0].desc) - 1;
266 int pidx;
269 * Firmware events.
271 snprintf(adapter->msix_info[MSIX_FW].desc, namelen,
272 "%s-FWeventq", adapter->name);
273 adapter->msix_info[MSIX_FW].desc[namelen] = 0;
276 * Ethernet queues.
278 for_each_port(adapter, pidx) {
279 struct net_device *dev = adapter->port[pidx];
280 const struct port_info *pi = netdev_priv(dev);
281 int qs, msi;
283 for (qs = 0, msi = MSIX_NIQFLINT;
284 qs < pi->nqsets;
285 qs++, msi++) {
286 snprintf(adapter->msix_info[msi].desc, namelen,
287 "%s-%d", dev->name, qs);
288 adapter->msix_info[msi].desc[namelen] = 0;
294 * Request all of our MSI-X resources.
296 static int request_msix_queue_irqs(struct adapter *adapter)
298 struct sge *s = &adapter->sge;
299 int rxq, msi, err;
302 * Firmware events.
304 err = request_irq(adapter->msix_info[MSIX_FW].vec, t4vf_sge_intr_msix,
305 0, adapter->msix_info[MSIX_FW].desc, &s->fw_evtq);
306 if (err)
307 return err;
310 * Ethernet queues.
312 msi = MSIX_NIQFLINT;
313 for_each_ethrxq(s, rxq) {
314 err = request_irq(adapter->msix_info[msi].vec,
315 t4vf_sge_intr_msix, 0,
316 adapter->msix_info[msi].desc,
317 &s->ethrxq[rxq].rspq);
318 if (err)
319 goto err_free_irqs;
320 msi++;
322 return 0;
324 err_free_irqs:
325 while (--rxq >= 0)
326 free_irq(adapter->msix_info[--msi].vec, &s->ethrxq[rxq].rspq);
327 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq);
328 return err;
332 * Free our MSI-X resources.
334 static void free_msix_queue_irqs(struct adapter *adapter)
336 struct sge *s = &adapter->sge;
337 int rxq, msi;
339 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq);
340 msi = MSIX_NIQFLINT;
341 for_each_ethrxq(s, rxq)
342 free_irq(adapter->msix_info[msi++].vec,
343 &s->ethrxq[rxq].rspq);
347 * Turn on NAPI and start up interrupts on a response queue.
349 static void qenable(struct sge_rspq *rspq)
351 napi_enable(&rspq->napi);
354 * 0-increment the Going To Sleep register to start the timer and
355 * enable interrupts.
357 t4_write_reg(rspq->adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
358 CIDXINC(0) |
359 SEINTARM(rspq->intr_params) |
360 INGRESSQID(rspq->cntxt_id));
364 * Enable NAPI scheduling and interrupt generation for all Receive Queues.
366 static void enable_rx(struct adapter *adapter)
368 int rxq;
369 struct sge *s = &adapter->sge;
371 for_each_ethrxq(s, rxq)
372 qenable(&s->ethrxq[rxq].rspq);
373 qenable(&s->fw_evtq);
376 * The interrupt queue doesn't use NAPI so we do the 0-increment of
377 * its Going To Sleep register here to get it started.
379 if (adapter->flags & USING_MSI)
380 t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
381 CIDXINC(0) |
382 SEINTARM(s->intrq.intr_params) |
383 INGRESSQID(s->intrq.cntxt_id));
388 * Wait until all NAPI handlers are descheduled.
390 static void quiesce_rx(struct adapter *adapter)
392 struct sge *s = &adapter->sge;
393 int rxq;
395 for_each_ethrxq(s, rxq)
396 napi_disable(&s->ethrxq[rxq].rspq.napi);
397 napi_disable(&s->fw_evtq.napi);
401 * Response queue handler for the firmware event queue.
403 static int fwevtq_handler(struct sge_rspq *rspq, const __be64 *rsp,
404 const struct pkt_gl *gl)
407 * Extract response opcode and get pointer to CPL message body.
409 struct adapter *adapter = rspq->adapter;
410 u8 opcode = ((const struct rss_header *)rsp)->opcode;
411 void *cpl = (void *)(rsp + 1);
413 switch (opcode) {
414 case CPL_FW6_MSG: {
416 * We've received an asynchronous message from the firmware.
418 const struct cpl_fw6_msg *fw_msg = cpl;
419 if (fw_msg->type == FW6_TYPE_CMD_RPL)
420 t4vf_handle_fw_rpl(adapter, fw_msg->data);
421 break;
424 case CPL_SGE_EGR_UPDATE: {
426 * We've received an Egress Queue Status Update message. We
427 * get these, if the SGE is configured to send these when the
428 * firmware passes certain points in processing our TX
429 * Ethernet Queue or if we make an explicit request for one.
430 * We use these updates to determine when we may need to
431 * restart a TX Ethernet Queue which was stopped for lack of
432 * free TX Queue Descriptors ...
434 const struct cpl_sge_egr_update *p = (void *)cpl;
435 unsigned int qid = EGR_QID(be32_to_cpu(p->opcode_qid));
436 struct sge *s = &adapter->sge;
437 struct sge_txq *tq;
438 struct sge_eth_txq *txq;
439 unsigned int eq_idx;
442 * Perform sanity checking on the Queue ID to make sure it
443 * really refers to one of our TX Ethernet Egress Queues which
444 * is active and matches the queue's ID. None of these error
445 * conditions should ever happen so we may want to either make
446 * them fatal and/or conditionalized under DEBUG.
448 eq_idx = EQ_IDX(s, qid);
449 if (unlikely(eq_idx >= MAX_EGRQ)) {
450 dev_err(adapter->pdev_dev,
451 "Egress Update QID %d out of range\n", qid);
452 break;
454 tq = s->egr_map[eq_idx];
455 if (unlikely(tq == NULL)) {
456 dev_err(adapter->pdev_dev,
457 "Egress Update QID %d TXQ=NULL\n", qid);
458 break;
460 txq = container_of(tq, struct sge_eth_txq, q);
461 if (unlikely(tq->abs_id != qid)) {
462 dev_err(adapter->pdev_dev,
463 "Egress Update QID %d refers to TXQ %d\n",
464 qid, tq->abs_id);
465 break;
469 * Restart a stopped TX Queue which has less than half of its
470 * TX ring in use ...
472 txq->q.restarts++;
473 netif_tx_wake_queue(txq->txq);
474 break;
477 default:
478 dev_err(adapter->pdev_dev,
479 "unexpected CPL %#x on FW event queue\n", opcode);
482 return 0;
486 * Allocate SGE TX/RX response queues. Determine how many sets of SGE queues
487 * to use and initializes them. We support multiple "Queue Sets" per port if
488 * we have MSI-X, otherwise just one queue set per port.
490 static int setup_sge_queues(struct adapter *adapter)
492 struct sge *s = &adapter->sge;
493 int err, pidx, msix;
496 * Clear "Queue Set" Free List Starving and TX Queue Mapping Error
497 * state.
499 bitmap_zero(s->starving_fl, MAX_EGRQ);
502 * If we're using MSI interrupt mode we need to set up a "forwarded
503 * interrupt" queue which we'll set up with our MSI vector. The rest
504 * of the ingress queues will be set up to forward their interrupts to
505 * this queue ... This must be first since t4vf_sge_alloc_rxq() uses
506 * the intrq's queue ID as the interrupt forwarding queue for the
507 * subsequent calls ...
509 if (adapter->flags & USING_MSI) {
510 err = t4vf_sge_alloc_rxq(adapter, &s->intrq, false,
511 adapter->port[0], 0, NULL, NULL);
512 if (err)
513 goto err_free_queues;
517 * Allocate our ingress queue for asynchronous firmware messages.
519 err = t4vf_sge_alloc_rxq(adapter, &s->fw_evtq, true, adapter->port[0],
520 MSIX_FW, NULL, fwevtq_handler);
521 if (err)
522 goto err_free_queues;
525 * Allocate each "port"'s initial Queue Sets. These can be changed
526 * later on ... up to the point where any interface on the adapter is
527 * brought up at which point lots of things get nailed down
528 * permanently ...
530 msix = MSIX_NIQFLINT;
531 for_each_port(adapter, pidx) {
532 struct net_device *dev = adapter->port[pidx];
533 struct port_info *pi = netdev_priv(dev);
534 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset];
535 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset];
536 int qs;
538 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
539 err = t4vf_sge_alloc_rxq(adapter, &rxq->rspq, false,
540 dev, msix++,
541 &rxq->fl, t4vf_ethrx_handler);
542 if (err)
543 goto err_free_queues;
545 err = t4vf_sge_alloc_eth_txq(adapter, txq, dev,
546 netdev_get_tx_queue(dev, qs),
547 s->fw_evtq.cntxt_id);
548 if (err)
549 goto err_free_queues;
551 rxq->rspq.idx = qs;
552 memset(&rxq->stats, 0, sizeof(rxq->stats));
557 * Create the reverse mappings for the queues.
559 s->egr_base = s->ethtxq[0].q.abs_id - s->ethtxq[0].q.cntxt_id;
560 s->ingr_base = s->ethrxq[0].rspq.abs_id - s->ethrxq[0].rspq.cntxt_id;
561 IQ_MAP(s, s->fw_evtq.abs_id) = &s->fw_evtq;
562 for_each_port(adapter, pidx) {
563 struct net_device *dev = adapter->port[pidx];
564 struct port_info *pi = netdev_priv(dev);
565 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset];
566 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset];
567 int qs;
569 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
570 IQ_MAP(s, rxq->rspq.abs_id) = &rxq->rspq;
571 EQ_MAP(s, txq->q.abs_id) = &txq->q;
574 * The FW_IQ_CMD doesn't return the Absolute Queue IDs
575 * for Free Lists but since all of the Egress Queues
576 * (including Free Lists) have Relative Queue IDs
577 * which are computed as Absolute - Base Queue ID, we
578 * can synthesize the Absolute Queue IDs for the Free
579 * Lists. This is useful for debugging purposes when
580 * we want to dump Queue Contexts via the PF Driver.
582 rxq->fl.abs_id = rxq->fl.cntxt_id + s->egr_base;
583 EQ_MAP(s, rxq->fl.abs_id) = &rxq->fl;
586 return 0;
588 err_free_queues:
589 t4vf_free_sge_resources(adapter);
590 return err;
594 * Set up Receive Side Scaling (RSS) to distribute packets to multiple receive
595 * queues. We configure the RSS CPU lookup table to distribute to the number
596 * of HW receive queues, and the response queue lookup table to narrow that
597 * down to the response queues actually configured for each "port" (Virtual
598 * Interface). We always configure the RSS mapping for all ports since the
599 * mapping table has plenty of entries.
601 static int setup_rss(struct adapter *adapter)
603 int pidx;
605 for_each_port(adapter, pidx) {
606 struct port_info *pi = adap2pinfo(adapter, pidx);
607 struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset];
608 u16 rss[MAX_PORT_QSETS];
609 int qs, err;
611 for (qs = 0; qs < pi->nqsets; qs++)
612 rss[qs] = rxq[qs].rspq.abs_id;
614 err = t4vf_config_rss_range(adapter, pi->viid,
615 0, pi->rss_size, rss, pi->nqsets);
616 if (err)
617 return err;
620 * Perform Global RSS Mode-specific initialization.
622 switch (adapter->params.rss.mode) {
623 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL:
625 * If Tunnel All Lookup isn't specified in the global
626 * RSS Configuration, then we need to specify a
627 * default Ingress Queue for any ingress packets which
628 * aren't hashed. We'll use our first ingress queue
629 * ...
631 if (!adapter->params.rss.u.basicvirtual.tnlalllookup) {
632 union rss_vi_config config;
633 err = t4vf_read_rss_vi_config(adapter,
634 pi->viid,
635 &config);
636 if (err)
637 return err;
638 config.basicvirtual.defaultq =
639 rxq[0].rspq.abs_id;
640 err = t4vf_write_rss_vi_config(adapter,
641 pi->viid,
642 &config);
643 if (err)
644 return err;
646 break;
650 return 0;
654 * Bring the adapter up. Called whenever we go from no "ports" open to having
655 * one open. This function performs the actions necessary to make an adapter
656 * operational, such as completing the initialization of HW modules, and
657 * enabling interrupts. Must be called with the rtnl lock held. (Note that
658 * this is called "cxgb_up" in the PF Driver.)
660 static int adapter_up(struct adapter *adapter)
662 int err;
665 * If this is the first time we've been called, perform basic
666 * adapter setup. Once we've done this, many of our adapter
667 * parameters can no longer be changed ...
669 if ((adapter->flags & FULL_INIT_DONE) == 0) {
670 err = setup_sge_queues(adapter);
671 if (err)
672 return err;
673 err = setup_rss(adapter);
674 if (err) {
675 t4vf_free_sge_resources(adapter);
676 return err;
679 if (adapter->flags & USING_MSIX)
680 name_msix_vecs(adapter);
681 adapter->flags |= FULL_INIT_DONE;
685 * Acquire our interrupt resources. We only support MSI-X and MSI.
687 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0);
688 if (adapter->flags & USING_MSIX)
689 err = request_msix_queue_irqs(adapter);
690 else
691 err = request_irq(adapter->pdev->irq,
692 t4vf_intr_handler(adapter), 0,
693 adapter->name, adapter);
694 if (err) {
695 dev_err(adapter->pdev_dev, "request_irq failed, err %d\n",
696 err);
697 return err;
701 * Enable NAPI ingress processing and return success.
703 enable_rx(adapter);
704 t4vf_sge_start(adapter);
705 return 0;
709 * Bring the adapter down. Called whenever the last "port" (Virtual
710 * Interface) closed. (Note that this routine is called "cxgb_down" in the PF
711 * Driver.)
713 static void adapter_down(struct adapter *adapter)
716 * Free interrupt resources.
718 if (adapter->flags & USING_MSIX)
719 free_msix_queue_irqs(adapter);
720 else
721 free_irq(adapter->pdev->irq, adapter);
724 * Wait for NAPI handlers to finish.
726 quiesce_rx(adapter);
730 * Start up a net device.
732 static int cxgb4vf_open(struct net_device *dev)
734 int err;
735 struct port_info *pi = netdev_priv(dev);
736 struct adapter *adapter = pi->adapter;
739 * If this is the first interface that we're opening on the "adapter",
740 * bring the "adapter" up now.
742 if (adapter->open_device_map == 0) {
743 err = adapter_up(adapter);
744 if (err)
745 return err;
749 * Note that this interface is up and start everything up ...
751 netif_set_real_num_tx_queues(dev, pi->nqsets);
752 err = netif_set_real_num_rx_queues(dev, pi->nqsets);
753 if (err)
754 return err;
755 set_bit(pi->port_id, &adapter->open_device_map);
756 link_start(dev);
757 netif_tx_start_all_queues(dev);
758 return 0;
762 * Shut down a net device. This routine is called "cxgb_close" in the PF
763 * Driver ...
765 static int cxgb4vf_stop(struct net_device *dev)
767 int ret;
768 struct port_info *pi = netdev_priv(dev);
769 struct adapter *adapter = pi->adapter;
771 netif_tx_stop_all_queues(dev);
772 netif_carrier_off(dev);
773 ret = t4vf_enable_vi(adapter, pi->viid, false, false);
774 pi->link_cfg.link_ok = 0;
776 clear_bit(pi->port_id, &adapter->open_device_map);
777 if (adapter->open_device_map == 0)
778 adapter_down(adapter);
779 return 0;
783 * Translate our basic statistics into the standard "ifconfig" statistics.
785 static struct net_device_stats *cxgb4vf_get_stats(struct net_device *dev)
787 struct t4vf_port_stats stats;
788 struct port_info *pi = netdev2pinfo(dev);
789 struct adapter *adapter = pi->adapter;
790 struct net_device_stats *ns = &dev->stats;
791 int err;
793 spin_lock(&adapter->stats_lock);
794 err = t4vf_get_port_stats(adapter, pi->pidx, &stats);
795 spin_unlock(&adapter->stats_lock);
797 memset(ns, 0, sizeof(*ns));
798 if (err)
799 return ns;
801 ns->tx_bytes = (stats.tx_bcast_bytes + stats.tx_mcast_bytes +
802 stats.tx_ucast_bytes + stats.tx_offload_bytes);
803 ns->tx_packets = (stats.tx_bcast_frames + stats.tx_mcast_frames +
804 stats.tx_ucast_frames + stats.tx_offload_frames);
805 ns->rx_bytes = (stats.rx_bcast_bytes + stats.rx_mcast_bytes +
806 stats.rx_ucast_bytes);
807 ns->rx_packets = (stats.rx_bcast_frames + stats.rx_mcast_frames +
808 stats.rx_ucast_frames);
809 ns->multicast = stats.rx_mcast_frames;
810 ns->tx_errors = stats.tx_drop_frames;
811 ns->rx_errors = stats.rx_err_frames;
813 return ns;
817 * Collect up to maxaddrs worth of a netdevice's unicast addresses into an
818 * array of addrss pointers and return the number collected.
820 static inline int collect_netdev_uc_list_addrs(const struct net_device *dev,
821 const u8 **addr,
822 unsigned int maxaddrs)
824 unsigned int naddr = 0;
825 const struct netdev_hw_addr *ha;
827 for_each_dev_addr(dev, ha) {
828 addr[naddr++] = ha->addr;
829 if (naddr >= maxaddrs)
830 break;
832 return naddr;
836 * Collect up to maxaddrs worth of a netdevice's multicast addresses into an
837 * array of addrss pointers and return the number collected.
839 static inline int collect_netdev_mc_list_addrs(const struct net_device *dev,
840 const u8 **addr,
841 unsigned int maxaddrs)
843 unsigned int naddr = 0;
844 const struct netdev_hw_addr *ha;
846 netdev_for_each_mc_addr(ha, dev) {
847 addr[naddr++] = ha->addr;
848 if (naddr >= maxaddrs)
849 break;
851 return naddr;
855 * Configure the exact and hash address filters to handle a port's multicast
856 * and secondary unicast MAC addresses.
858 static int set_addr_filters(const struct net_device *dev, bool sleep)
860 u64 mhash = 0;
861 u64 uhash = 0;
862 bool free = true;
863 u16 filt_idx[7];
864 const u8 *addr[7];
865 int ret, naddr = 0;
866 const struct port_info *pi = netdev_priv(dev);
868 /* first do the secondary unicast addresses */
869 naddr = collect_netdev_uc_list_addrs(dev, addr, ARRAY_SIZE(addr));
870 if (naddr > 0) {
871 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
872 naddr, addr, filt_idx, &uhash, sleep);
873 if (ret < 0)
874 return ret;
876 free = false;
879 /* next set up the multicast addresses */
880 naddr = collect_netdev_mc_list_addrs(dev, addr, ARRAY_SIZE(addr));
881 if (naddr > 0) {
882 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
883 naddr, addr, filt_idx, &mhash, sleep);
884 if (ret < 0)
885 return ret;
888 return t4vf_set_addr_hash(pi->adapter, pi->viid, uhash != 0,
889 uhash | mhash, sleep);
893 * Set RX properties of a port, such as promiscruity, address filters, and MTU.
894 * If @mtu is -1 it is left unchanged.
896 static int set_rxmode(struct net_device *dev, int mtu, bool sleep_ok)
898 int ret;
899 struct port_info *pi = netdev_priv(dev);
901 ret = set_addr_filters(dev, sleep_ok);
902 if (ret == 0)
903 ret = t4vf_set_rxmode(pi->adapter, pi->viid, -1,
904 (dev->flags & IFF_PROMISC) != 0,
905 (dev->flags & IFF_ALLMULTI) != 0,
906 1, -1, sleep_ok);
907 return ret;
911 * Set the current receive modes on the device.
913 static void cxgb4vf_set_rxmode(struct net_device *dev)
915 /* unfortunately we can't return errors to the stack */
916 set_rxmode(dev, -1, false);
920 * Find the entry in the interrupt holdoff timer value array which comes
921 * closest to the specified interrupt holdoff value.
923 static int closest_timer(const struct sge *s, int us)
925 int i, timer_idx = 0, min_delta = INT_MAX;
927 for (i = 0; i < ARRAY_SIZE(s->timer_val); i++) {
928 int delta = us - s->timer_val[i];
929 if (delta < 0)
930 delta = -delta;
931 if (delta < min_delta) {
932 min_delta = delta;
933 timer_idx = i;
936 return timer_idx;
939 static int closest_thres(const struct sge *s, int thres)
941 int i, delta, pktcnt_idx = 0, min_delta = INT_MAX;
943 for (i = 0; i < ARRAY_SIZE(s->counter_val); i++) {
944 delta = thres - s->counter_val[i];
945 if (delta < 0)
946 delta = -delta;
947 if (delta < min_delta) {
948 min_delta = delta;
949 pktcnt_idx = i;
952 return pktcnt_idx;
956 * Return a queue's interrupt hold-off time in us. 0 means no timer.
958 static unsigned int qtimer_val(const struct adapter *adapter,
959 const struct sge_rspq *rspq)
961 unsigned int timer_idx = QINTR_TIMER_IDX_GET(rspq->intr_params);
963 return timer_idx < SGE_NTIMERS
964 ? adapter->sge.timer_val[timer_idx]
965 : 0;
969 * set_rxq_intr_params - set a queue's interrupt holdoff parameters
970 * @adapter: the adapter
971 * @rspq: the RX response queue
972 * @us: the hold-off time in us, or 0 to disable timer
973 * @cnt: the hold-off packet count, or 0 to disable counter
975 * Sets an RX response queue's interrupt hold-off time and packet count.
976 * At least one of the two needs to be enabled for the queue to generate
977 * interrupts.
979 static int set_rxq_intr_params(struct adapter *adapter, struct sge_rspq *rspq,
980 unsigned int us, unsigned int cnt)
982 unsigned int timer_idx;
985 * If both the interrupt holdoff timer and count are specified as
986 * zero, default to a holdoff count of 1 ...
988 if ((us | cnt) == 0)
989 cnt = 1;
992 * If an interrupt holdoff count has been specified, then find the
993 * closest configured holdoff count and use that. If the response
994 * queue has already been created, then update its queue context
995 * parameters ...
997 if (cnt) {
998 int err;
999 u32 v, pktcnt_idx;
1001 pktcnt_idx = closest_thres(&adapter->sge, cnt);
1002 if (rspq->desc && rspq->pktcnt_idx != pktcnt_idx) {
1003 v = FW_PARAMS_MNEM(FW_PARAMS_MNEM_DMAQ) |
1004 FW_PARAMS_PARAM_X(
1005 FW_PARAMS_PARAM_DMAQ_IQ_INTCNTTHRESH) |
1006 FW_PARAMS_PARAM_YZ(rspq->cntxt_id);
1007 err = t4vf_set_params(adapter, 1, &v, &pktcnt_idx);
1008 if (err)
1009 return err;
1011 rspq->pktcnt_idx = pktcnt_idx;
1015 * Compute the closest holdoff timer index from the supplied holdoff
1016 * timer value.
1018 timer_idx = (us == 0
1019 ? SGE_TIMER_RSTRT_CNTR
1020 : closest_timer(&adapter->sge, us));
1023 * Update the response queue's interrupt coalescing parameters and
1024 * return success.
1026 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
1027 (cnt > 0 ? QINTR_CNT_EN : 0));
1028 return 0;
1032 * Return a version number to identify the type of adapter. The scheme is:
1033 * - bits 0..9: chip version
1034 * - bits 10..15: chip revision
1036 static inline unsigned int mk_adap_vers(const struct adapter *adapter)
1039 * Chip version 4, revision 0x3f (cxgb4vf).
1041 return 4 | (0x3f << 10);
1045 * Execute the specified ioctl command.
1047 static int cxgb4vf_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1049 int ret = 0;
1051 switch (cmd) {
1053 * The VF Driver doesn't have access to any of the other
1054 * common Ethernet device ioctl()'s (like reading/writing
1055 * PHY registers, etc.
1058 default:
1059 ret = -EOPNOTSUPP;
1060 break;
1062 return ret;
1066 * Change the device's MTU.
1068 static int cxgb4vf_change_mtu(struct net_device *dev, int new_mtu)
1070 int ret;
1071 struct port_info *pi = netdev_priv(dev);
1073 /* accommodate SACK */
1074 if (new_mtu < 81)
1075 return -EINVAL;
1077 ret = t4vf_set_rxmode(pi->adapter, pi->viid, new_mtu,
1078 -1, -1, -1, -1, true);
1079 if (!ret)
1080 dev->mtu = new_mtu;
1081 return ret;
1085 * Change the devices MAC address.
1087 static int cxgb4vf_set_mac_addr(struct net_device *dev, void *_addr)
1089 int ret;
1090 struct sockaddr *addr = _addr;
1091 struct port_info *pi = netdev_priv(dev);
1093 if (!is_valid_ether_addr(addr->sa_data))
1094 return -EINVAL;
1096 ret = t4vf_change_mac(pi->adapter, pi->viid, pi->xact_addr_filt,
1097 addr->sa_data, true);
1098 if (ret < 0)
1099 return ret;
1101 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1102 pi->xact_addr_filt = ret;
1103 return 0;
1107 * Return a TX Queue on which to send the specified skb.
1109 static u16 cxgb4vf_select_queue(struct net_device *dev, struct sk_buff *skb)
1112 * XXX For now just use the default hash but we probably want to
1113 * XXX look at other possibilities ...
1115 return skb_tx_hash(dev, skb);
1118 #ifdef CONFIG_NET_POLL_CONTROLLER
1120 * Poll all of our receive queues. This is called outside of normal interrupt
1121 * context.
1123 static void cxgb4vf_poll_controller(struct net_device *dev)
1125 struct port_info *pi = netdev_priv(dev);
1126 struct adapter *adapter = pi->adapter;
1128 if (adapter->flags & USING_MSIX) {
1129 struct sge_eth_rxq *rxq;
1130 int nqsets;
1132 rxq = &adapter->sge.ethrxq[pi->first_qset];
1133 for (nqsets = pi->nqsets; nqsets; nqsets--) {
1134 t4vf_sge_intr_msix(0, &rxq->rspq);
1135 rxq++;
1137 } else
1138 t4vf_intr_handler(adapter)(0, adapter);
1140 #endif
1143 * Ethtool operations.
1144 * ===================
1146 * Note that we don't support any ethtool operations which change the physical
1147 * state of the port to which we're linked.
1151 * Return current port link settings.
1153 static int cxgb4vf_get_settings(struct net_device *dev,
1154 struct ethtool_cmd *cmd)
1156 const struct port_info *pi = netdev_priv(dev);
1158 cmd->supported = pi->link_cfg.supported;
1159 cmd->advertising = pi->link_cfg.advertising;
1160 cmd->speed = netif_carrier_ok(dev) ? pi->link_cfg.speed : -1;
1161 cmd->duplex = DUPLEX_FULL;
1163 cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
1164 cmd->phy_address = pi->port_id;
1165 cmd->transceiver = XCVR_EXTERNAL;
1166 cmd->autoneg = pi->link_cfg.autoneg;
1167 cmd->maxtxpkt = 0;
1168 cmd->maxrxpkt = 0;
1169 return 0;
1173 * Return our driver information.
1175 static void cxgb4vf_get_drvinfo(struct net_device *dev,
1176 struct ethtool_drvinfo *drvinfo)
1178 struct adapter *adapter = netdev2adap(dev);
1180 strcpy(drvinfo->driver, KBUILD_MODNAME);
1181 strcpy(drvinfo->version, DRV_VERSION);
1182 strcpy(drvinfo->bus_info, pci_name(to_pci_dev(dev->dev.parent)));
1183 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1184 "%u.%u.%u.%u, TP %u.%u.%u.%u",
1185 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.fwrev),
1186 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.fwrev),
1187 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.fwrev),
1188 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.fwrev),
1189 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.tprev),
1190 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.tprev),
1191 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.tprev),
1192 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.tprev));
1196 * Return current adapter message level.
1198 static u32 cxgb4vf_get_msglevel(struct net_device *dev)
1200 return netdev2adap(dev)->msg_enable;
1204 * Set current adapter message level.
1206 static void cxgb4vf_set_msglevel(struct net_device *dev, u32 msglevel)
1208 netdev2adap(dev)->msg_enable = msglevel;
1212 * Return the device's current Queue Set ring size parameters along with the
1213 * allowed maximum values. Since ethtool doesn't understand the concept of
1214 * multi-queue devices, we just return the current values associated with the
1215 * first Queue Set.
1217 static void cxgb4vf_get_ringparam(struct net_device *dev,
1218 struct ethtool_ringparam *rp)
1220 const struct port_info *pi = netdev_priv(dev);
1221 const struct sge *s = &pi->adapter->sge;
1223 rp->rx_max_pending = MAX_RX_BUFFERS;
1224 rp->rx_mini_max_pending = MAX_RSPQ_ENTRIES;
1225 rp->rx_jumbo_max_pending = 0;
1226 rp->tx_max_pending = MAX_TXQ_ENTRIES;
1228 rp->rx_pending = s->ethrxq[pi->first_qset].fl.size - MIN_FL_RESID;
1229 rp->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size;
1230 rp->rx_jumbo_pending = 0;
1231 rp->tx_pending = s->ethtxq[pi->first_qset].q.size;
1235 * Set the Queue Set ring size parameters for the device. Again, since
1236 * ethtool doesn't allow for the concept of multiple queues per device, we'll
1237 * apply these new values across all of the Queue Sets associated with the
1238 * device -- after vetting them of course!
1240 static int cxgb4vf_set_ringparam(struct net_device *dev,
1241 struct ethtool_ringparam *rp)
1243 const struct port_info *pi = netdev_priv(dev);
1244 struct adapter *adapter = pi->adapter;
1245 struct sge *s = &adapter->sge;
1246 int qs;
1248 if (rp->rx_pending > MAX_RX_BUFFERS ||
1249 rp->rx_jumbo_pending ||
1250 rp->tx_pending > MAX_TXQ_ENTRIES ||
1251 rp->rx_mini_pending > MAX_RSPQ_ENTRIES ||
1252 rp->rx_mini_pending < MIN_RSPQ_ENTRIES ||
1253 rp->rx_pending < MIN_FL_ENTRIES ||
1254 rp->tx_pending < MIN_TXQ_ENTRIES)
1255 return -EINVAL;
1257 if (adapter->flags & FULL_INIT_DONE)
1258 return -EBUSY;
1260 for (qs = pi->first_qset; qs < pi->first_qset + pi->nqsets; qs++) {
1261 s->ethrxq[qs].fl.size = rp->rx_pending + MIN_FL_RESID;
1262 s->ethrxq[qs].rspq.size = rp->rx_mini_pending;
1263 s->ethtxq[qs].q.size = rp->tx_pending;
1265 return 0;
1269 * Return the interrupt holdoff timer and count for the first Queue Set on the
1270 * device. Our extension ioctl() (the cxgbtool interface) allows the
1271 * interrupt holdoff timer to be read on all of the device's Queue Sets.
1273 static int cxgb4vf_get_coalesce(struct net_device *dev,
1274 struct ethtool_coalesce *coalesce)
1276 const struct port_info *pi = netdev_priv(dev);
1277 const struct adapter *adapter = pi->adapter;
1278 const struct sge_rspq *rspq = &adapter->sge.ethrxq[pi->first_qset].rspq;
1280 coalesce->rx_coalesce_usecs = qtimer_val(adapter, rspq);
1281 coalesce->rx_max_coalesced_frames =
1282 ((rspq->intr_params & QINTR_CNT_EN)
1283 ? adapter->sge.counter_val[rspq->pktcnt_idx]
1284 : 0);
1285 return 0;
1289 * Set the RX interrupt holdoff timer and count for the first Queue Set on the
1290 * interface. Our extension ioctl() (the cxgbtool interface) allows us to set
1291 * the interrupt holdoff timer on any of the device's Queue Sets.
1293 static int cxgb4vf_set_coalesce(struct net_device *dev,
1294 struct ethtool_coalesce *coalesce)
1296 const struct port_info *pi = netdev_priv(dev);
1297 struct adapter *adapter = pi->adapter;
1299 return set_rxq_intr_params(adapter,
1300 &adapter->sge.ethrxq[pi->first_qset].rspq,
1301 coalesce->rx_coalesce_usecs,
1302 coalesce->rx_max_coalesced_frames);
1306 * Report current port link pause parameter settings.
1308 static void cxgb4vf_get_pauseparam(struct net_device *dev,
1309 struct ethtool_pauseparam *pauseparam)
1311 struct port_info *pi = netdev_priv(dev);
1313 pauseparam->autoneg = (pi->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
1314 pauseparam->rx_pause = (pi->link_cfg.fc & PAUSE_RX) != 0;
1315 pauseparam->tx_pause = (pi->link_cfg.fc & PAUSE_TX) != 0;
1319 * Return whether RX Checksum Offloading is currently enabled for the device.
1321 static u32 cxgb4vf_get_rx_csum(struct net_device *dev)
1323 struct port_info *pi = netdev_priv(dev);
1325 return (pi->rx_offload & RX_CSO) != 0;
1329 * Turn RX Checksum Offloading on or off for the device.
1331 static int cxgb4vf_set_rx_csum(struct net_device *dev, u32 csum)
1333 struct port_info *pi = netdev_priv(dev);
1335 if (csum)
1336 pi->rx_offload |= RX_CSO;
1337 else
1338 pi->rx_offload &= ~RX_CSO;
1339 return 0;
1343 * Identify the port by blinking the port's LED.
1345 static int cxgb4vf_phys_id(struct net_device *dev, u32 id)
1347 struct port_info *pi = netdev_priv(dev);
1349 return t4vf_identify_port(pi->adapter, pi->viid, 5);
1353 * Port stats maintained per queue of the port.
1355 struct queue_port_stats {
1356 u64 tso;
1357 u64 tx_csum;
1358 u64 rx_csum;
1359 u64 vlan_ex;
1360 u64 vlan_ins;
1364 * Strings for the ETH_SS_STATS statistics set ("ethtool -S"). Note that
1365 * these need to match the order of statistics returned by
1366 * t4vf_get_port_stats().
1368 static const char stats_strings[][ETH_GSTRING_LEN] = {
1370 * These must match the layout of the t4vf_port_stats structure.
1372 "TxBroadcastBytes ",
1373 "TxBroadcastFrames ",
1374 "TxMulticastBytes ",
1375 "TxMulticastFrames ",
1376 "TxUnicastBytes ",
1377 "TxUnicastFrames ",
1378 "TxDroppedFrames ",
1379 "TxOffloadBytes ",
1380 "TxOffloadFrames ",
1381 "RxBroadcastBytes ",
1382 "RxBroadcastFrames ",
1383 "RxMulticastBytes ",
1384 "RxMulticastFrames ",
1385 "RxUnicastBytes ",
1386 "RxUnicastFrames ",
1387 "RxErrorFrames ",
1390 * These are accumulated per-queue statistics and must match the
1391 * order of the fields in the queue_port_stats structure.
1393 "TSO ",
1394 "TxCsumOffload ",
1395 "RxCsumGood ",
1396 "VLANextractions ",
1397 "VLANinsertions ",
1401 * Return the number of statistics in the specified statistics set.
1403 static int cxgb4vf_get_sset_count(struct net_device *dev, int sset)
1405 switch (sset) {
1406 case ETH_SS_STATS:
1407 return ARRAY_SIZE(stats_strings);
1408 default:
1409 return -EOPNOTSUPP;
1411 /*NOTREACHED*/
1415 * Return the strings for the specified statistics set.
1417 static void cxgb4vf_get_strings(struct net_device *dev,
1418 u32 sset,
1419 u8 *data)
1421 switch (sset) {
1422 case ETH_SS_STATS:
1423 memcpy(data, stats_strings, sizeof(stats_strings));
1424 break;
1429 * Small utility routine to accumulate queue statistics across the queues of
1430 * a "port".
1432 static void collect_sge_port_stats(const struct adapter *adapter,
1433 const struct port_info *pi,
1434 struct queue_port_stats *stats)
1436 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[pi->first_qset];
1437 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset];
1438 int qs;
1440 memset(stats, 0, sizeof(*stats));
1441 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
1442 stats->tso += txq->tso;
1443 stats->tx_csum += txq->tx_cso;
1444 stats->rx_csum += rxq->stats.rx_cso;
1445 stats->vlan_ex += rxq->stats.vlan_ex;
1446 stats->vlan_ins += txq->vlan_ins;
1451 * Return the ETH_SS_STATS statistics set.
1453 static void cxgb4vf_get_ethtool_stats(struct net_device *dev,
1454 struct ethtool_stats *stats,
1455 u64 *data)
1457 struct port_info *pi = netdev2pinfo(dev);
1458 struct adapter *adapter = pi->adapter;
1459 int err = t4vf_get_port_stats(adapter, pi->pidx,
1460 (struct t4vf_port_stats *)data);
1461 if (err)
1462 memset(data, 0, sizeof(struct t4vf_port_stats));
1464 data += sizeof(struct t4vf_port_stats) / sizeof(u64);
1465 collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
1469 * Return the size of our register map.
1471 static int cxgb4vf_get_regs_len(struct net_device *dev)
1473 return T4VF_REGMAP_SIZE;
1477 * Dump a block of registers, start to end inclusive, into a buffer.
1479 static void reg_block_dump(struct adapter *adapter, void *regbuf,
1480 unsigned int start, unsigned int end)
1482 u32 *bp = regbuf + start - T4VF_REGMAP_START;
1484 for ( ; start <= end; start += sizeof(u32)) {
1486 * Avoid reading the Mailbox Control register since that
1487 * can trigger a Mailbox Ownership Arbitration cycle and
1488 * interfere with communication with the firmware.
1490 if (start == T4VF_CIM_BASE_ADDR + CIM_VF_EXT_MAILBOX_CTRL)
1491 *bp++ = 0xffff;
1492 else
1493 *bp++ = t4_read_reg(adapter, start);
1498 * Copy our entire register map into the provided buffer.
1500 static void cxgb4vf_get_regs(struct net_device *dev,
1501 struct ethtool_regs *regs,
1502 void *regbuf)
1504 struct adapter *adapter = netdev2adap(dev);
1506 regs->version = mk_adap_vers(adapter);
1509 * Fill in register buffer with our register map.
1511 memset(regbuf, 0, T4VF_REGMAP_SIZE);
1513 reg_block_dump(adapter, regbuf,
1514 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_FIRST,
1515 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_LAST);
1516 reg_block_dump(adapter, regbuf,
1517 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_FIRST,
1518 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_LAST);
1519 reg_block_dump(adapter, regbuf,
1520 T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_FIRST,
1521 T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_LAST);
1522 reg_block_dump(adapter, regbuf,
1523 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_FIRST,
1524 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_LAST);
1526 reg_block_dump(adapter, regbuf,
1527 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_FIRST,
1528 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_LAST);
1532 * Report current Wake On LAN settings.
1534 static void cxgb4vf_get_wol(struct net_device *dev,
1535 struct ethtool_wolinfo *wol)
1537 wol->supported = 0;
1538 wol->wolopts = 0;
1539 memset(&wol->sopass, 0, sizeof(wol->sopass));
1543 * Set TCP Segmentation Offloading feature capabilities.
1545 static int cxgb4vf_set_tso(struct net_device *dev, u32 tso)
1547 if (tso)
1548 dev->features |= NETIF_F_TSO | NETIF_F_TSO6;
1549 else
1550 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
1551 return 0;
1554 static struct ethtool_ops cxgb4vf_ethtool_ops = {
1555 .get_settings = cxgb4vf_get_settings,
1556 .get_drvinfo = cxgb4vf_get_drvinfo,
1557 .get_msglevel = cxgb4vf_get_msglevel,
1558 .set_msglevel = cxgb4vf_set_msglevel,
1559 .get_ringparam = cxgb4vf_get_ringparam,
1560 .set_ringparam = cxgb4vf_set_ringparam,
1561 .get_coalesce = cxgb4vf_get_coalesce,
1562 .set_coalesce = cxgb4vf_set_coalesce,
1563 .get_pauseparam = cxgb4vf_get_pauseparam,
1564 .get_rx_csum = cxgb4vf_get_rx_csum,
1565 .set_rx_csum = cxgb4vf_set_rx_csum,
1566 .set_tx_csum = ethtool_op_set_tx_ipv6_csum,
1567 .set_sg = ethtool_op_set_sg,
1568 .get_link = ethtool_op_get_link,
1569 .get_strings = cxgb4vf_get_strings,
1570 .phys_id = cxgb4vf_phys_id,
1571 .get_sset_count = cxgb4vf_get_sset_count,
1572 .get_ethtool_stats = cxgb4vf_get_ethtool_stats,
1573 .get_regs_len = cxgb4vf_get_regs_len,
1574 .get_regs = cxgb4vf_get_regs,
1575 .get_wol = cxgb4vf_get_wol,
1576 .set_tso = cxgb4vf_set_tso,
1580 * /sys/kernel/debug/cxgb4vf support code and data.
1581 * ================================================
1585 * Show SGE Queue Set information. We display QPL Queues Sets per line.
1587 #define QPL 4
1589 static int sge_qinfo_show(struct seq_file *seq, void *v)
1591 struct adapter *adapter = seq->private;
1592 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1593 int qs, r = (uintptr_t)v - 1;
1595 if (r)
1596 seq_putc(seq, '\n');
1598 #define S3(fmt_spec, s, v) \
1599 do {\
1600 seq_printf(seq, "%-12s", s); \
1601 for (qs = 0; qs < n; ++qs) \
1602 seq_printf(seq, " %16" fmt_spec, v); \
1603 seq_putc(seq, '\n'); \
1604 } while (0)
1605 #define S(s, v) S3("s", s, v)
1606 #define T(s, v) S3("u", s, txq[qs].v)
1607 #define R(s, v) S3("u", s, rxq[qs].v)
1609 if (r < eth_entries) {
1610 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1611 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1612 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1614 S("QType:", "Ethernet");
1615 S("Interface:",
1616 (rxq[qs].rspq.netdev
1617 ? rxq[qs].rspq.netdev->name
1618 : "N/A"));
1619 S3("d", "Port:",
1620 (rxq[qs].rspq.netdev
1621 ? ((struct port_info *)
1622 netdev_priv(rxq[qs].rspq.netdev))->port_id
1623 : -1));
1624 T("TxQ ID:", q.abs_id);
1625 T("TxQ size:", q.size);
1626 T("TxQ inuse:", q.in_use);
1627 T("TxQ PIdx:", q.pidx);
1628 T("TxQ CIdx:", q.cidx);
1629 R("RspQ ID:", rspq.abs_id);
1630 R("RspQ size:", rspq.size);
1631 R("RspQE size:", rspq.iqe_len);
1632 S3("u", "Intr delay:", qtimer_val(adapter, &rxq[qs].rspq));
1633 S3("u", "Intr pktcnt:",
1634 adapter->sge.counter_val[rxq[qs].rspq.pktcnt_idx]);
1635 R("RspQ CIdx:", rspq.cidx);
1636 R("RspQ Gen:", rspq.gen);
1637 R("FL ID:", fl.abs_id);
1638 R("FL size:", fl.size - MIN_FL_RESID);
1639 R("FL avail:", fl.avail);
1640 R("FL PIdx:", fl.pidx);
1641 R("FL CIdx:", fl.cidx);
1642 return 0;
1645 r -= eth_entries;
1646 if (r == 0) {
1647 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1649 seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue");
1650 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id);
1651 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1652 qtimer_val(adapter, evtq));
1653 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1654 adapter->sge.counter_val[evtq->pktcnt_idx]);
1655 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", evtq->cidx);
1656 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen);
1657 } else if (r == 1) {
1658 const struct sge_rspq *intrq = &adapter->sge.intrq;
1660 seq_printf(seq, "%-12s %16s\n", "QType:", "Interrupt Queue");
1661 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", intrq->abs_id);
1662 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1663 qtimer_val(adapter, intrq));
1664 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1665 adapter->sge.counter_val[intrq->pktcnt_idx]);
1666 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", intrq->cidx);
1667 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", intrq->gen);
1670 #undef R
1671 #undef T
1672 #undef S
1673 #undef S3
1675 return 0;
1679 * Return the number of "entries" in our "file". We group the multi-Queue
1680 * sections with QPL Queue Sets per "entry". The sections of the output are:
1682 * Ethernet RX/TX Queue Sets
1683 * Firmware Event Queue
1684 * Forwarded Interrupt Queue (if in MSI mode)
1686 static int sge_queue_entries(const struct adapter *adapter)
1688 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1689 ((adapter->flags & USING_MSI) != 0);
1692 static void *sge_queue_start(struct seq_file *seq, loff_t *pos)
1694 int entries = sge_queue_entries(seq->private);
1696 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1699 static void sge_queue_stop(struct seq_file *seq, void *v)
1703 static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos)
1705 int entries = sge_queue_entries(seq->private);
1707 ++*pos;
1708 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1711 static const struct seq_operations sge_qinfo_seq_ops = {
1712 .start = sge_queue_start,
1713 .next = sge_queue_next,
1714 .stop = sge_queue_stop,
1715 .show = sge_qinfo_show
1718 static int sge_qinfo_open(struct inode *inode, struct file *file)
1720 int res = seq_open(file, &sge_qinfo_seq_ops);
1722 if (!res) {
1723 struct seq_file *seq = file->private_data;
1724 seq->private = inode->i_private;
1726 return res;
1729 static const struct file_operations sge_qinfo_debugfs_fops = {
1730 .owner = THIS_MODULE,
1731 .open = sge_qinfo_open,
1732 .read = seq_read,
1733 .llseek = seq_lseek,
1734 .release = seq_release,
1738 * Show SGE Queue Set statistics. We display QPL Queues Sets per line.
1740 #define QPL 4
1742 static int sge_qstats_show(struct seq_file *seq, void *v)
1744 struct adapter *adapter = seq->private;
1745 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1746 int qs, r = (uintptr_t)v - 1;
1748 if (r)
1749 seq_putc(seq, '\n');
1751 #define S3(fmt, s, v) \
1752 do { \
1753 seq_printf(seq, "%-16s", s); \
1754 for (qs = 0; qs < n; ++qs) \
1755 seq_printf(seq, " %8" fmt, v); \
1756 seq_putc(seq, '\n'); \
1757 } while (0)
1758 #define S(s, v) S3("s", s, v)
1760 #define T3(fmt, s, v) S3(fmt, s, txq[qs].v)
1761 #define T(s, v) T3("lu", s, v)
1763 #define R3(fmt, s, v) S3(fmt, s, rxq[qs].v)
1764 #define R(s, v) R3("lu", s, v)
1766 if (r < eth_entries) {
1767 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1768 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1769 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1771 S("QType:", "Ethernet");
1772 S("Interface:",
1773 (rxq[qs].rspq.netdev
1774 ? rxq[qs].rspq.netdev->name
1775 : "N/A"));
1776 R3("u", "RspQNullInts:", rspq.unhandled_irqs);
1777 R("RxPackets:", stats.pkts);
1778 R("RxCSO:", stats.rx_cso);
1779 R("VLANxtract:", stats.vlan_ex);
1780 R("LROmerged:", stats.lro_merged);
1781 R("LROpackets:", stats.lro_pkts);
1782 R("RxDrops:", stats.rx_drops);
1783 T("TSO:", tso);
1784 T("TxCSO:", tx_cso);
1785 T("VLANins:", vlan_ins);
1786 T("TxQFull:", q.stops);
1787 T("TxQRestarts:", q.restarts);
1788 T("TxMapErr:", mapping_err);
1789 R("FLAllocErr:", fl.alloc_failed);
1790 R("FLLrgAlcErr:", fl.large_alloc_failed);
1791 R("FLStarving:", fl.starving);
1792 return 0;
1795 r -= eth_entries;
1796 if (r == 0) {
1797 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1799 seq_printf(seq, "%-8s %16s\n", "QType:", "FW event queue");
1800 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1801 evtq->unhandled_irqs);
1802 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", evtq->cidx);
1803 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", evtq->gen);
1804 } else if (r == 1) {
1805 const struct sge_rspq *intrq = &adapter->sge.intrq;
1807 seq_printf(seq, "%-8s %16s\n", "QType:", "Interrupt Queue");
1808 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1809 intrq->unhandled_irqs);
1810 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", intrq->cidx);
1811 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", intrq->gen);
1814 #undef R
1815 #undef T
1816 #undef S
1817 #undef R3
1818 #undef T3
1819 #undef S3
1821 return 0;
1825 * Return the number of "entries" in our "file". We group the multi-Queue
1826 * sections with QPL Queue Sets per "entry". The sections of the output are:
1828 * Ethernet RX/TX Queue Sets
1829 * Firmware Event Queue
1830 * Forwarded Interrupt Queue (if in MSI mode)
1832 static int sge_qstats_entries(const struct adapter *adapter)
1834 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1835 ((adapter->flags & USING_MSI) != 0);
1838 static void *sge_qstats_start(struct seq_file *seq, loff_t *pos)
1840 int entries = sge_qstats_entries(seq->private);
1842 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1845 static void sge_qstats_stop(struct seq_file *seq, void *v)
1849 static void *sge_qstats_next(struct seq_file *seq, void *v, loff_t *pos)
1851 int entries = sge_qstats_entries(seq->private);
1853 (*pos)++;
1854 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1857 static const struct seq_operations sge_qstats_seq_ops = {
1858 .start = sge_qstats_start,
1859 .next = sge_qstats_next,
1860 .stop = sge_qstats_stop,
1861 .show = sge_qstats_show
1864 static int sge_qstats_open(struct inode *inode, struct file *file)
1866 int res = seq_open(file, &sge_qstats_seq_ops);
1868 if (res == 0) {
1869 struct seq_file *seq = file->private_data;
1870 seq->private = inode->i_private;
1872 return res;
1875 static const struct file_operations sge_qstats_proc_fops = {
1876 .owner = THIS_MODULE,
1877 .open = sge_qstats_open,
1878 .read = seq_read,
1879 .llseek = seq_lseek,
1880 .release = seq_release,
1884 * Show PCI-E SR-IOV Virtual Function Resource Limits.
1886 static int resources_show(struct seq_file *seq, void *v)
1888 struct adapter *adapter = seq->private;
1889 struct vf_resources *vfres = &adapter->params.vfres;
1891 #define S(desc, fmt, var) \
1892 seq_printf(seq, "%-60s " fmt "\n", \
1893 desc " (" #var "):", vfres->var)
1895 S("Virtual Interfaces", "%d", nvi);
1896 S("Egress Queues", "%d", neq);
1897 S("Ethernet Control", "%d", nethctrl);
1898 S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint);
1899 S("Ingress Queues", "%d", niq);
1900 S("Traffic Class", "%d", tc);
1901 S("Port Access Rights Mask", "%#x", pmask);
1902 S("MAC Address Filters", "%d", nexactf);
1903 S("Firmware Command Read Capabilities", "%#x", r_caps);
1904 S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps);
1906 #undef S
1908 return 0;
1911 static int resources_open(struct inode *inode, struct file *file)
1913 return single_open(file, resources_show, inode->i_private);
1916 static const struct file_operations resources_proc_fops = {
1917 .owner = THIS_MODULE,
1918 .open = resources_open,
1919 .read = seq_read,
1920 .llseek = seq_lseek,
1921 .release = single_release,
1925 * Show Virtual Interfaces.
1927 static int interfaces_show(struct seq_file *seq, void *v)
1929 if (v == SEQ_START_TOKEN) {
1930 seq_puts(seq, "Interface Port VIID\n");
1931 } else {
1932 struct adapter *adapter = seq->private;
1933 int pidx = (uintptr_t)v - 2;
1934 struct net_device *dev = adapter->port[pidx];
1935 struct port_info *pi = netdev_priv(dev);
1937 seq_printf(seq, "%9s %4d %#5x\n",
1938 dev->name, pi->port_id, pi->viid);
1940 return 0;
1943 static inline void *interfaces_get_idx(struct adapter *adapter, loff_t pos)
1945 return pos <= adapter->params.nports
1946 ? (void *)(uintptr_t)(pos + 1)
1947 : NULL;
1950 static void *interfaces_start(struct seq_file *seq, loff_t *pos)
1952 return *pos
1953 ? interfaces_get_idx(seq->private, *pos)
1954 : SEQ_START_TOKEN;
1957 static void *interfaces_next(struct seq_file *seq, void *v, loff_t *pos)
1959 (*pos)++;
1960 return interfaces_get_idx(seq->private, *pos);
1963 static void interfaces_stop(struct seq_file *seq, void *v)
1967 static const struct seq_operations interfaces_seq_ops = {
1968 .start = interfaces_start,
1969 .next = interfaces_next,
1970 .stop = interfaces_stop,
1971 .show = interfaces_show
1974 static int interfaces_open(struct inode *inode, struct file *file)
1976 int res = seq_open(file, &interfaces_seq_ops);
1978 if (res == 0) {
1979 struct seq_file *seq = file->private_data;
1980 seq->private = inode->i_private;
1982 return res;
1985 static const struct file_operations interfaces_proc_fops = {
1986 .owner = THIS_MODULE,
1987 .open = interfaces_open,
1988 .read = seq_read,
1989 .llseek = seq_lseek,
1990 .release = seq_release,
1994 * /sys/kernel/debugfs/cxgb4vf/ files list.
1996 struct cxgb4vf_debugfs_entry {
1997 const char *name; /* name of debugfs node */
1998 mode_t mode; /* file system mode */
1999 const struct file_operations *fops;
2002 static struct cxgb4vf_debugfs_entry debugfs_files[] = {
2003 { "sge_qinfo", S_IRUGO, &sge_qinfo_debugfs_fops },
2004 { "sge_qstats", S_IRUGO, &sge_qstats_proc_fops },
2005 { "resources", S_IRUGO, &resources_proc_fops },
2006 { "interfaces", S_IRUGO, &interfaces_proc_fops },
2010 * Module and device initialization and cleanup code.
2011 * ==================================================
2015 * Set up out /sys/kernel/debug/cxgb4vf sub-nodes. We assume that the
2016 * directory (debugfs_root) has already been set up.
2018 static int __devinit setup_debugfs(struct adapter *adapter)
2020 int i;
2022 BUG_ON(adapter->debugfs_root == NULL);
2025 * Debugfs support is best effort.
2027 for (i = 0; i < ARRAY_SIZE(debugfs_files); i++)
2028 (void)debugfs_create_file(debugfs_files[i].name,
2029 debugfs_files[i].mode,
2030 adapter->debugfs_root,
2031 (void *)adapter,
2032 debugfs_files[i].fops);
2034 return 0;
2038 * Tear down the /sys/kernel/debug/cxgb4vf sub-nodes created above. We leave
2039 * it to our caller to tear down the directory (debugfs_root).
2041 static void __devexit cleanup_debugfs(struct adapter *adapter)
2043 BUG_ON(adapter->debugfs_root == NULL);
2046 * Unlike our sister routine cleanup_proc(), we don't need to remove
2047 * individual entries because a call will be made to
2048 * debugfs_remove_recursive(). We just need to clean up any ancillary
2049 * persistent state.
2051 /* nothing to do */
2055 * Perform early "adapter" initialization. This is where we discover what
2056 * adapter parameters we're going to be using and initialize basic adapter
2057 * hardware support.
2059 static int adap_init0(struct adapter *adapter)
2061 struct vf_resources *vfres = &adapter->params.vfres;
2062 struct sge_params *sge_params = &adapter->params.sge;
2063 struct sge *s = &adapter->sge;
2064 unsigned int ethqsets;
2065 int err;
2068 * Wait for the device to become ready before proceeding ...
2070 err = t4vf_wait_dev_ready(adapter);
2071 if (err) {
2072 dev_err(adapter->pdev_dev, "device didn't become ready:"
2073 " err=%d\n", err);
2074 return err;
2078 * Grab basic operational parameters. These will predominantly have
2079 * been set up by the Physical Function Driver or will be hard coded
2080 * into the adapter. We just have to live with them ... Note that
2081 * we _must_ get our VPD parameters before our SGE parameters because
2082 * we need to know the adapter's core clock from the VPD in order to
2083 * properly decode the SGE Timer Values.
2085 err = t4vf_get_dev_params(adapter);
2086 if (err) {
2087 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2088 " device parameters: err=%d\n", err);
2089 return err;
2091 err = t4vf_get_vpd_params(adapter);
2092 if (err) {
2093 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2094 " VPD parameters: err=%d\n", err);
2095 return err;
2097 err = t4vf_get_sge_params(adapter);
2098 if (err) {
2099 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2100 " SGE parameters: err=%d\n", err);
2101 return err;
2103 err = t4vf_get_rss_glb_config(adapter);
2104 if (err) {
2105 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2106 " RSS parameters: err=%d\n", err);
2107 return err;
2109 if (adapter->params.rss.mode !=
2110 FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
2111 dev_err(adapter->pdev_dev, "unable to operate with global RSS"
2112 " mode %d\n", adapter->params.rss.mode);
2113 return -EINVAL;
2115 err = t4vf_sge_init(adapter);
2116 if (err) {
2117 dev_err(adapter->pdev_dev, "unable to use adapter parameters:"
2118 " err=%d\n", err);
2119 return err;
2123 * Retrieve our RX interrupt holdoff timer values and counter
2124 * threshold values from the SGE parameters.
2126 s->timer_val[0] = core_ticks_to_us(adapter,
2127 TIMERVALUE0_GET(sge_params->sge_timer_value_0_and_1));
2128 s->timer_val[1] = core_ticks_to_us(adapter,
2129 TIMERVALUE1_GET(sge_params->sge_timer_value_0_and_1));
2130 s->timer_val[2] = core_ticks_to_us(adapter,
2131 TIMERVALUE0_GET(sge_params->sge_timer_value_2_and_3));
2132 s->timer_val[3] = core_ticks_to_us(adapter,
2133 TIMERVALUE1_GET(sge_params->sge_timer_value_2_and_3));
2134 s->timer_val[4] = core_ticks_to_us(adapter,
2135 TIMERVALUE0_GET(sge_params->sge_timer_value_4_and_5));
2136 s->timer_val[5] = core_ticks_to_us(adapter,
2137 TIMERVALUE1_GET(sge_params->sge_timer_value_4_and_5));
2139 s->counter_val[0] =
2140 THRESHOLD_0_GET(sge_params->sge_ingress_rx_threshold);
2141 s->counter_val[1] =
2142 THRESHOLD_1_GET(sge_params->sge_ingress_rx_threshold);
2143 s->counter_val[2] =
2144 THRESHOLD_2_GET(sge_params->sge_ingress_rx_threshold);
2145 s->counter_val[3] =
2146 THRESHOLD_3_GET(sge_params->sge_ingress_rx_threshold);
2149 * Grab our Virtual Interface resource allocation, extract the
2150 * features that we're interested in and do a bit of sanity testing on
2151 * what we discover.
2153 err = t4vf_get_vfres(adapter);
2154 if (err) {
2155 dev_err(adapter->pdev_dev, "unable to get virtual interface"
2156 " resources: err=%d\n", err);
2157 return err;
2161 * The number of "ports" which we support is equal to the number of
2162 * Virtual Interfaces with which we've been provisioned.
2164 adapter->params.nports = vfres->nvi;
2165 if (adapter->params.nports > MAX_NPORTS) {
2166 dev_warn(adapter->pdev_dev, "only using %d of %d allowed"
2167 " virtual interfaces\n", MAX_NPORTS,
2168 adapter->params.nports);
2169 adapter->params.nports = MAX_NPORTS;
2173 * We need to reserve a number of the ingress queues with Free List
2174 * and Interrupt capabilities for special interrupt purposes (like
2175 * asynchronous firmware messages, or forwarded interrupts if we're
2176 * using MSI). The rest of the FL/Intr-capable ingress queues will be
2177 * matched up one-for-one with Ethernet/Control egress queues in order
2178 * to form "Queue Sets" which will be aportioned between the "ports".
2179 * For each Queue Set, we'll need the ability to allocate two Egress
2180 * Contexts -- one for the Ingress Queue Free List and one for the TX
2181 * Ethernet Queue.
2183 ethqsets = vfres->niqflint - INGQ_EXTRAS;
2184 if (vfres->nethctrl != ethqsets) {
2185 dev_warn(adapter->pdev_dev, "unequal number of [available]"
2186 " ingress/egress queues (%d/%d); using minimum for"
2187 " number of Queue Sets\n", ethqsets, vfres->nethctrl);
2188 ethqsets = min(vfres->nethctrl, ethqsets);
2190 if (vfres->neq < ethqsets*2) {
2191 dev_warn(adapter->pdev_dev, "Not enough Egress Contexts (%d)"
2192 " to support Queue Sets (%d); reducing allowed Queue"
2193 " Sets\n", vfres->neq, ethqsets);
2194 ethqsets = vfres->neq/2;
2196 if (ethqsets > MAX_ETH_QSETS) {
2197 dev_warn(adapter->pdev_dev, "only using %d of %d allowed Queue"
2198 " Sets\n", MAX_ETH_QSETS, adapter->sge.max_ethqsets);
2199 ethqsets = MAX_ETH_QSETS;
2201 if (vfres->niq != 0 || vfres->neq > ethqsets*2) {
2202 dev_warn(adapter->pdev_dev, "unused resources niq/neq (%d/%d)"
2203 " ignored\n", vfres->niq, vfres->neq - ethqsets*2);
2205 adapter->sge.max_ethqsets = ethqsets;
2208 * Check for various parameter sanity issues. Most checks simply
2209 * result in us using fewer resources than our provissioning but we
2210 * do need at least one "port" with which to work ...
2212 if (adapter->sge.max_ethqsets < adapter->params.nports) {
2213 dev_warn(adapter->pdev_dev, "only using %d of %d available"
2214 " virtual interfaces (too few Queue Sets)\n",
2215 adapter->sge.max_ethqsets, adapter->params.nports);
2216 adapter->params.nports = adapter->sge.max_ethqsets;
2218 if (adapter->params.nports == 0) {
2219 dev_err(adapter->pdev_dev, "no virtual interfaces configured/"
2220 "usable!\n");
2221 return -EINVAL;
2223 return 0;
2226 static inline void init_rspq(struct sge_rspq *rspq, u8 timer_idx,
2227 u8 pkt_cnt_idx, unsigned int size,
2228 unsigned int iqe_size)
2230 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
2231 (pkt_cnt_idx < SGE_NCOUNTERS ? QINTR_CNT_EN : 0));
2232 rspq->pktcnt_idx = (pkt_cnt_idx < SGE_NCOUNTERS
2233 ? pkt_cnt_idx
2234 : 0);
2235 rspq->iqe_len = iqe_size;
2236 rspq->size = size;
2240 * Perform default configuration of DMA queues depending on the number and
2241 * type of ports we found and the number of available CPUs. Most settings can
2242 * be modified by the admin via ethtool and cxgbtool prior to the adapter
2243 * being brought up for the first time.
2245 static void __devinit cfg_queues(struct adapter *adapter)
2247 struct sge *s = &adapter->sge;
2248 int q10g, n10g, qidx, pidx, qs;
2251 * We should not be called till we know how many Queue Sets we can
2252 * support. In particular, this means that we need to know what kind
2253 * of interrupts we'll be using ...
2255 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0);
2258 * Count the number of 10GbE Virtual Interfaces that we have.
2260 n10g = 0;
2261 for_each_port(adapter, pidx)
2262 n10g += is_10g_port(&adap2pinfo(adapter, pidx)->link_cfg);
2265 * We default to 1 queue per non-10G port and up to # of cores queues
2266 * per 10G port.
2268 if (n10g == 0)
2269 q10g = 0;
2270 else {
2271 int n1g = (adapter->params.nports - n10g);
2272 q10g = (adapter->sge.max_ethqsets - n1g) / n10g;
2273 if (q10g > num_online_cpus())
2274 q10g = num_online_cpus();
2278 * Allocate the "Queue Sets" to the various Virtual Interfaces.
2279 * The layout will be established in setup_sge_queues() when the
2280 * adapter is brough up for the first time.
2282 qidx = 0;
2283 for_each_port(adapter, pidx) {
2284 struct port_info *pi = adap2pinfo(adapter, pidx);
2286 pi->first_qset = qidx;
2287 pi->nqsets = is_10g_port(&pi->link_cfg) ? q10g : 1;
2288 qidx += pi->nqsets;
2290 s->ethqsets = qidx;
2293 * Set up default Queue Set parameters ... Start off with the
2294 * shortest interrupt holdoff timer.
2296 for (qs = 0; qs < s->max_ethqsets; qs++) {
2297 struct sge_eth_rxq *rxq = &s->ethrxq[qs];
2298 struct sge_eth_txq *txq = &s->ethtxq[qs];
2300 init_rspq(&rxq->rspq, 0, 0, 1024, L1_CACHE_BYTES);
2301 rxq->fl.size = 72;
2302 txq->q.size = 1024;
2306 * The firmware event queue is used for link state changes and
2307 * notifications of TX DMA completions.
2309 init_rspq(&s->fw_evtq, SGE_TIMER_RSTRT_CNTR, 0, 512,
2310 L1_CACHE_BYTES);
2313 * The forwarded interrupt queue is used when we're in MSI interrupt
2314 * mode. In this mode all interrupts associated with RX queues will
2315 * be forwarded to a single queue which we'll associate with our MSI
2316 * interrupt vector. The messages dropped in the forwarded interrupt
2317 * queue will indicate which ingress queue needs servicing ... This
2318 * queue needs to be large enough to accommodate all of the ingress
2319 * queues which are forwarding their interrupt (+1 to prevent the PIDX
2320 * from equalling the CIDX if every ingress queue has an outstanding
2321 * interrupt). The queue doesn't need to be any larger because no
2322 * ingress queue will ever have more than one outstanding interrupt at
2323 * any time ...
2325 init_rspq(&s->intrq, SGE_TIMER_RSTRT_CNTR, 0, MSIX_ENTRIES + 1,
2326 L1_CACHE_BYTES);
2330 * Reduce the number of Ethernet queues across all ports to at most n.
2331 * n provides at least one queue per port.
2333 static void __devinit reduce_ethqs(struct adapter *adapter, int n)
2335 int i;
2336 struct port_info *pi;
2339 * While we have too many active Ether Queue Sets, interate across the
2340 * "ports" and reduce their individual Queue Set allocations.
2342 BUG_ON(n < adapter->params.nports);
2343 while (n < adapter->sge.ethqsets)
2344 for_each_port(adapter, i) {
2345 pi = adap2pinfo(adapter, i);
2346 if (pi->nqsets > 1) {
2347 pi->nqsets--;
2348 adapter->sge.ethqsets--;
2349 if (adapter->sge.ethqsets <= n)
2350 break;
2355 * Reassign the starting Queue Sets for each of the "ports" ...
2357 n = 0;
2358 for_each_port(adapter, i) {
2359 pi = adap2pinfo(adapter, i);
2360 pi->first_qset = n;
2361 n += pi->nqsets;
2366 * We need to grab enough MSI-X vectors to cover our interrupt needs. Ideally
2367 * we get a separate MSI-X vector for every "Queue Set" plus any extras we
2368 * need. Minimally we need one for every Virtual Interface plus those needed
2369 * for our "extras". Note that this process may lower the maximum number of
2370 * allowed Queue Sets ...
2372 static int __devinit enable_msix(struct adapter *adapter)
2374 int i, err, want, need;
2375 struct msix_entry entries[MSIX_ENTRIES];
2376 struct sge *s = &adapter->sge;
2378 for (i = 0; i < MSIX_ENTRIES; ++i)
2379 entries[i].entry = i;
2382 * We _want_ enough MSI-X interrupts to cover all of our "Queue Sets"
2383 * plus those needed for our "extras" (for example, the firmware
2384 * message queue). We _need_ at least one "Queue Set" per Virtual
2385 * Interface plus those needed for our "extras". So now we get to see
2386 * if the song is right ...
2388 want = s->max_ethqsets + MSIX_EXTRAS;
2389 need = adapter->params.nports + MSIX_EXTRAS;
2390 while ((err = pci_enable_msix(adapter->pdev, entries, want)) >= need)
2391 want = err;
2393 if (err == 0) {
2394 int nqsets = want - MSIX_EXTRAS;
2395 if (nqsets < s->max_ethqsets) {
2396 dev_warn(adapter->pdev_dev, "only enough MSI-X vectors"
2397 " for %d Queue Sets\n", nqsets);
2398 s->max_ethqsets = nqsets;
2399 if (nqsets < s->ethqsets)
2400 reduce_ethqs(adapter, nqsets);
2402 for (i = 0; i < want; ++i)
2403 adapter->msix_info[i].vec = entries[i].vector;
2404 } else if (err > 0) {
2405 pci_disable_msix(adapter->pdev);
2406 dev_info(adapter->pdev_dev, "only %d MSI-X vectors left,"
2407 " not using MSI-X\n", err);
2409 return err;
2412 #ifdef HAVE_NET_DEVICE_OPS
2413 static const struct net_device_ops cxgb4vf_netdev_ops = {
2414 .ndo_open = cxgb4vf_open,
2415 .ndo_stop = cxgb4vf_stop,
2416 .ndo_start_xmit = t4vf_eth_xmit,
2417 .ndo_get_stats = cxgb4vf_get_stats,
2418 .ndo_set_rx_mode = cxgb4vf_set_rxmode,
2419 .ndo_set_mac_address = cxgb4vf_set_mac_addr,
2420 .ndo_select_queue = cxgb4vf_select_queue,
2421 .ndo_validate_addr = eth_validate_addr,
2422 .ndo_do_ioctl = cxgb4vf_do_ioctl,
2423 .ndo_change_mtu = cxgb4vf_change_mtu,
2424 .ndo_vlan_rx_register = cxgb4vf_vlan_rx_register,
2425 #ifdef CONFIG_NET_POLL_CONTROLLER
2426 .ndo_poll_controller = cxgb4vf_poll_controller,
2427 #endif
2429 #endif
2432 * "Probe" a device: initialize a device and construct all kernel and driver
2433 * state needed to manage the device. This routine is called "init_one" in
2434 * the PF Driver ...
2436 static int __devinit cxgb4vf_pci_probe(struct pci_dev *pdev,
2437 const struct pci_device_id *ent)
2439 static int version_printed;
2441 int pci_using_dac;
2442 int err, pidx;
2443 unsigned int pmask;
2444 struct adapter *adapter;
2445 struct port_info *pi;
2446 struct net_device *netdev;
2449 * Vet our module parameters.
2451 if (msi != MSI_MSIX && msi != MSI_MSI) {
2452 dev_err(&pdev->dev, "bad module parameter msi=%d; must be %d"
2453 " (MSI-X or MSI) or %d (MSI)\n", msi, MSI_MSIX,
2454 MSI_MSI);
2455 err = -EINVAL;
2456 goto err_out;
2460 * Print our driver banner the first time we're called to initialize a
2461 * device.
2463 if (version_printed == 0) {
2464 printk(KERN_INFO "%s - version %s\n", DRV_DESC, DRV_VERSION);
2465 version_printed = 1;
2470 * Initialize generic PCI device state.
2472 err = pci_enable_device(pdev);
2473 if (err) {
2474 dev_err(&pdev->dev, "cannot enable PCI device\n");
2475 return err;
2479 * Reserve PCI resources for the device. If we can't get them some
2480 * other driver may have already claimed the device ...
2482 err = pci_request_regions(pdev, KBUILD_MODNAME);
2483 if (err) {
2484 dev_err(&pdev->dev, "cannot obtain PCI resources\n");
2485 goto err_disable_device;
2489 * Set up our DMA mask: try for 64-bit address masking first and
2490 * fall back to 32-bit if we can't get 64 bits ...
2492 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2493 if (err == 0) {
2494 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
2495 if (err) {
2496 dev_err(&pdev->dev, "unable to obtain 64-bit DMA for"
2497 " coherent allocations\n");
2498 goto err_release_regions;
2500 pci_using_dac = 1;
2501 } else {
2502 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2503 if (err != 0) {
2504 dev_err(&pdev->dev, "no usable DMA configuration\n");
2505 goto err_release_regions;
2507 pci_using_dac = 0;
2511 * Enable bus mastering for the device ...
2513 pci_set_master(pdev);
2516 * Allocate our adapter data structure and attach it to the device.
2518 adapter = kzalloc(sizeof(*adapter), GFP_KERNEL);
2519 if (!adapter) {
2520 err = -ENOMEM;
2521 goto err_release_regions;
2523 pci_set_drvdata(pdev, adapter);
2524 adapter->pdev = pdev;
2525 adapter->pdev_dev = &pdev->dev;
2528 * Initialize SMP data synchronization resources.
2530 spin_lock_init(&adapter->stats_lock);
2533 * Map our I/O registers in BAR0.
2535 adapter->regs = pci_ioremap_bar(pdev, 0);
2536 if (!adapter->regs) {
2537 dev_err(&pdev->dev, "cannot map device registers\n");
2538 err = -ENOMEM;
2539 goto err_free_adapter;
2543 * Initialize adapter level features.
2545 adapter->name = pci_name(pdev);
2546 adapter->msg_enable = dflt_msg_enable;
2547 err = adap_init0(adapter);
2548 if (err)
2549 goto err_unmap_bar;
2552 * Allocate our "adapter ports" and stitch everything together.
2554 pmask = adapter->params.vfres.pmask;
2555 for_each_port(adapter, pidx) {
2556 int port_id, viid;
2559 * We simplistically allocate our virtual interfaces
2560 * sequentially across the port numbers to which we have
2561 * access rights. This should be configurable in some manner
2562 * ...
2564 if (pmask == 0)
2565 break;
2566 port_id = ffs(pmask) - 1;
2567 pmask &= ~(1 << port_id);
2568 viid = t4vf_alloc_vi(adapter, port_id);
2569 if (viid < 0) {
2570 dev_err(&pdev->dev, "cannot allocate VI for port %d:"
2571 " err=%d\n", port_id, viid);
2572 err = viid;
2573 goto err_free_dev;
2577 * Allocate our network device and stitch things together.
2579 netdev = alloc_etherdev_mq(sizeof(struct port_info),
2580 MAX_PORT_QSETS);
2581 if (netdev == NULL) {
2582 dev_err(&pdev->dev, "cannot allocate netdev for"
2583 " port %d\n", port_id);
2584 t4vf_free_vi(adapter, viid);
2585 err = -ENOMEM;
2586 goto err_free_dev;
2588 adapter->port[pidx] = netdev;
2589 SET_NETDEV_DEV(netdev, &pdev->dev);
2590 pi = netdev_priv(netdev);
2591 pi->adapter = adapter;
2592 pi->pidx = pidx;
2593 pi->port_id = port_id;
2594 pi->viid = viid;
2597 * Initialize the starting state of our "port" and register
2598 * it.
2600 pi->xact_addr_filt = -1;
2601 pi->rx_offload = RX_CSO;
2602 netif_carrier_off(netdev);
2603 netif_tx_stop_all_queues(netdev);
2604 netdev->irq = pdev->irq;
2606 netdev->features = (NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
2607 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2608 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX |
2609 NETIF_F_GRO);
2610 if (pci_using_dac)
2611 netdev->features |= NETIF_F_HIGHDMA;
2612 netdev->vlan_features =
2613 (netdev->features &
2614 ~(NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX));
2616 #ifdef HAVE_NET_DEVICE_OPS
2617 netdev->netdev_ops = &cxgb4vf_netdev_ops;
2618 #else
2619 netdev->vlan_rx_register = cxgb4vf_vlan_rx_register;
2620 netdev->open = cxgb4vf_open;
2621 netdev->stop = cxgb4vf_stop;
2622 netdev->hard_start_xmit = t4vf_eth_xmit;
2623 netdev->get_stats = cxgb4vf_get_stats;
2624 netdev->set_rx_mode = cxgb4vf_set_rxmode;
2625 netdev->do_ioctl = cxgb4vf_do_ioctl;
2626 netdev->change_mtu = cxgb4vf_change_mtu;
2627 netdev->set_mac_address = cxgb4vf_set_mac_addr;
2628 netdev->select_queue = cxgb4vf_select_queue;
2629 #ifdef CONFIG_NET_POLL_CONTROLLER
2630 netdev->poll_controller = cxgb4vf_poll_controller;
2631 #endif
2632 #endif
2633 SET_ETHTOOL_OPS(netdev, &cxgb4vf_ethtool_ops);
2636 * Initialize the hardware/software state for the port.
2638 err = t4vf_port_init(adapter, pidx);
2639 if (err) {
2640 dev_err(&pdev->dev, "cannot initialize port %d\n",
2641 pidx);
2642 goto err_free_dev;
2647 * The "card" is now ready to go. If any errors occur during device
2648 * registration we do not fail the whole "card" but rather proceed
2649 * only with the ports we manage to register successfully. However we
2650 * must register at least one net device.
2652 for_each_port(adapter, pidx) {
2653 netdev = adapter->port[pidx];
2654 if (netdev == NULL)
2655 continue;
2657 err = register_netdev(netdev);
2658 if (err) {
2659 dev_warn(&pdev->dev, "cannot register net device %s,"
2660 " skipping\n", netdev->name);
2661 continue;
2664 set_bit(pidx, &adapter->registered_device_map);
2666 if (adapter->registered_device_map == 0) {
2667 dev_err(&pdev->dev, "could not register any net devices\n");
2668 goto err_free_dev;
2672 * Set up our debugfs entries.
2674 if (cxgb4vf_debugfs_root) {
2675 adapter->debugfs_root =
2676 debugfs_create_dir(pci_name(pdev),
2677 cxgb4vf_debugfs_root);
2678 if (adapter->debugfs_root == NULL)
2679 dev_warn(&pdev->dev, "could not create debugfs"
2680 " directory");
2681 else
2682 setup_debugfs(adapter);
2686 * See what interrupts we'll be using. If we've been configured to
2687 * use MSI-X interrupts, try to enable them but fall back to using
2688 * MSI interrupts if we can't enable MSI-X interrupts. If we can't
2689 * get MSI interrupts we bail with the error.
2691 if (msi == MSI_MSIX && enable_msix(adapter) == 0)
2692 adapter->flags |= USING_MSIX;
2693 else {
2694 err = pci_enable_msi(pdev);
2695 if (err) {
2696 dev_err(&pdev->dev, "Unable to allocate %s interrupts;"
2697 " err=%d\n",
2698 msi == MSI_MSIX ? "MSI-X or MSI" : "MSI", err);
2699 goto err_free_debugfs;
2701 adapter->flags |= USING_MSI;
2705 * Now that we know how many "ports" we have and what their types are,
2706 * and how many Queue Sets we can support, we can configure our queue
2707 * resources.
2709 cfg_queues(adapter);
2712 * Print a short notice on the existance and configuration of the new
2713 * VF network device ...
2715 for_each_port(adapter, pidx) {
2716 dev_info(adapter->pdev_dev, "%s: Chelsio VF NIC PCIe %s\n",
2717 adapter->port[pidx]->name,
2718 (adapter->flags & USING_MSIX) ? "MSI-X" :
2719 (adapter->flags & USING_MSI) ? "MSI" : "");
2723 * Return success!
2725 return 0;
2728 * Error recovery and exit code. Unwind state that's been created
2729 * so far and return the error.
2732 err_free_debugfs:
2733 if (adapter->debugfs_root) {
2734 cleanup_debugfs(adapter);
2735 debugfs_remove_recursive(adapter->debugfs_root);
2738 err_free_dev:
2739 for_each_port(adapter, pidx) {
2740 netdev = adapter->port[pidx];
2741 if (netdev == NULL)
2742 continue;
2743 pi = netdev_priv(netdev);
2744 t4vf_free_vi(adapter, pi->viid);
2745 if (test_bit(pidx, &adapter->registered_device_map))
2746 unregister_netdev(netdev);
2747 free_netdev(netdev);
2750 err_unmap_bar:
2751 iounmap(adapter->regs);
2753 err_free_adapter:
2754 kfree(adapter);
2755 pci_set_drvdata(pdev, NULL);
2757 err_release_regions:
2758 pci_release_regions(pdev);
2759 pci_set_drvdata(pdev, NULL);
2760 pci_clear_master(pdev);
2762 err_disable_device:
2763 pci_disable_device(pdev);
2765 err_out:
2766 return err;
2770 * "Remove" a device: tear down all kernel and driver state created in the
2771 * "probe" routine and quiesce the device (disable interrupts, etc.). (Note
2772 * that this is called "remove_one" in the PF Driver.)
2774 static void __devexit cxgb4vf_pci_remove(struct pci_dev *pdev)
2776 struct adapter *adapter = pci_get_drvdata(pdev);
2779 * Tear down driver state associated with device.
2781 if (adapter) {
2782 int pidx;
2785 * Stop all of our activity. Unregister network port,
2786 * disable interrupts, etc.
2788 for_each_port(adapter, pidx)
2789 if (test_bit(pidx, &adapter->registered_device_map))
2790 unregister_netdev(adapter->port[pidx]);
2791 t4vf_sge_stop(adapter);
2792 if (adapter->flags & USING_MSIX) {
2793 pci_disable_msix(adapter->pdev);
2794 adapter->flags &= ~USING_MSIX;
2795 } else if (adapter->flags & USING_MSI) {
2796 pci_disable_msi(adapter->pdev);
2797 adapter->flags &= ~USING_MSI;
2801 * Tear down our debugfs entries.
2803 if (adapter->debugfs_root) {
2804 cleanup_debugfs(adapter);
2805 debugfs_remove_recursive(adapter->debugfs_root);
2809 * Free all of the various resources which we've acquired ...
2811 t4vf_free_sge_resources(adapter);
2812 for_each_port(adapter, pidx) {
2813 struct net_device *netdev = adapter->port[pidx];
2814 struct port_info *pi;
2816 if (netdev == NULL)
2817 continue;
2819 pi = netdev_priv(netdev);
2820 t4vf_free_vi(adapter, pi->viid);
2821 free_netdev(netdev);
2823 iounmap(adapter->regs);
2824 kfree(adapter);
2825 pci_set_drvdata(pdev, NULL);
2829 * Disable the device and release its PCI resources.
2831 pci_disable_device(pdev);
2832 pci_clear_master(pdev);
2833 pci_release_regions(pdev);
2837 * PCI Device registration data structures.
2839 #define CH_DEVICE(devid, idx) \
2840 { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
2842 static struct pci_device_id cxgb4vf_pci_tbl[] = {
2843 CH_DEVICE(0xb000, 0), /* PE10K FPGA */
2844 CH_DEVICE(0x4800, 0), /* T440-dbg */
2845 CH_DEVICE(0x4801, 0), /* T420-cr */
2846 CH_DEVICE(0x4802, 0), /* T422-cr */
2847 { 0, }
2850 MODULE_DESCRIPTION(DRV_DESC);
2851 MODULE_AUTHOR("Chelsio Communications");
2852 MODULE_LICENSE("Dual BSD/GPL");
2853 MODULE_VERSION(DRV_VERSION);
2854 MODULE_DEVICE_TABLE(pci, cxgb4vf_pci_tbl);
2856 static struct pci_driver cxgb4vf_driver = {
2857 .name = KBUILD_MODNAME,
2858 .id_table = cxgb4vf_pci_tbl,
2859 .probe = cxgb4vf_pci_probe,
2860 .remove = __devexit_p(cxgb4vf_pci_remove),
2864 * Initialize global driver state.
2866 static int __init cxgb4vf_module_init(void)
2868 int ret;
2870 /* Debugfs support is optional, just warn if this fails */
2871 cxgb4vf_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
2872 if (!cxgb4vf_debugfs_root)
2873 printk(KERN_WARNING KBUILD_MODNAME ": could not create"
2874 " debugfs entry, continuing\n");
2876 ret = pci_register_driver(&cxgb4vf_driver);
2877 if (ret < 0)
2878 debugfs_remove(cxgb4vf_debugfs_root);
2879 return ret;
2883 * Tear down global driver state.
2885 static void __exit cxgb4vf_module_exit(void)
2887 pci_unregister_driver(&cxgb4vf_driver);
2888 debugfs_remove(cxgb4vf_debugfs_root);
2891 module_init(cxgb4vf_module_init);
2892 module_exit(cxgb4vf_module_exit);