ARM: 7409/1: Do not call flush_cache_user_range with mmap_sem held
[linux/fpc-iii.git] / drivers / net / cxgb4vf / cxgb4vf_main.c
blobe71c08e547e4aa789eced9428244ad68c01b5fa4
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_IQFLINT; qs < pi->nqsets; qs++, msi++) {
284 snprintf(adapter->msix_info[msi].desc, namelen,
285 "%s-%d", dev->name, qs);
286 adapter->msix_info[msi].desc[namelen] = 0;
292 * Request all of our MSI-X resources.
294 static int request_msix_queue_irqs(struct adapter *adapter)
296 struct sge *s = &adapter->sge;
297 int rxq, msi, err;
300 * Firmware events.
302 err = request_irq(adapter->msix_info[MSIX_FW].vec, t4vf_sge_intr_msix,
303 0, adapter->msix_info[MSIX_FW].desc, &s->fw_evtq);
304 if (err)
305 return err;
308 * Ethernet queues.
310 msi = MSIX_IQFLINT;
311 for_each_ethrxq(s, rxq) {
312 err = request_irq(adapter->msix_info[msi].vec,
313 t4vf_sge_intr_msix, 0,
314 adapter->msix_info[msi].desc,
315 &s->ethrxq[rxq].rspq);
316 if (err)
317 goto err_free_irqs;
318 msi++;
320 return 0;
322 err_free_irqs:
323 while (--rxq >= 0)
324 free_irq(adapter->msix_info[--msi].vec, &s->ethrxq[rxq].rspq);
325 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq);
326 return err;
330 * Free our MSI-X resources.
332 static void free_msix_queue_irqs(struct adapter *adapter)
334 struct sge *s = &adapter->sge;
335 int rxq, msi;
337 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq);
338 msi = MSIX_IQFLINT;
339 for_each_ethrxq(s, rxq)
340 free_irq(adapter->msix_info[msi++].vec,
341 &s->ethrxq[rxq].rspq);
345 * Turn on NAPI and start up interrupts on a response queue.
347 static void qenable(struct sge_rspq *rspq)
349 napi_enable(&rspq->napi);
352 * 0-increment the Going To Sleep register to start the timer and
353 * enable interrupts.
355 t4_write_reg(rspq->adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
356 CIDXINC(0) |
357 SEINTARM(rspq->intr_params) |
358 INGRESSQID(rspq->cntxt_id));
362 * Enable NAPI scheduling and interrupt generation for all Receive Queues.
364 static void enable_rx(struct adapter *adapter)
366 int rxq;
367 struct sge *s = &adapter->sge;
369 for_each_ethrxq(s, rxq)
370 qenable(&s->ethrxq[rxq].rspq);
371 qenable(&s->fw_evtq);
374 * The interrupt queue doesn't use NAPI so we do the 0-increment of
375 * its Going To Sleep register here to get it started.
377 if (adapter->flags & USING_MSI)
378 t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS,
379 CIDXINC(0) |
380 SEINTARM(s->intrq.intr_params) |
381 INGRESSQID(s->intrq.cntxt_id));
386 * Wait until all NAPI handlers are descheduled.
388 static void quiesce_rx(struct adapter *adapter)
390 struct sge *s = &adapter->sge;
391 int rxq;
393 for_each_ethrxq(s, rxq)
394 napi_disable(&s->ethrxq[rxq].rspq.napi);
395 napi_disable(&s->fw_evtq.napi);
399 * Response queue handler for the firmware event queue.
401 static int fwevtq_handler(struct sge_rspq *rspq, const __be64 *rsp,
402 const struct pkt_gl *gl)
405 * Extract response opcode and get pointer to CPL message body.
407 struct adapter *adapter = rspq->adapter;
408 u8 opcode = ((const struct rss_header *)rsp)->opcode;
409 void *cpl = (void *)(rsp + 1);
411 switch (opcode) {
412 case CPL_FW6_MSG: {
414 * We've received an asynchronous message from the firmware.
416 const struct cpl_fw6_msg *fw_msg = cpl;
417 if (fw_msg->type == FW6_TYPE_CMD_RPL)
418 t4vf_handle_fw_rpl(adapter, fw_msg->data);
419 break;
422 case CPL_SGE_EGR_UPDATE: {
424 * We've received an Egress Queue Status Update message. We
425 * get these, if the SGE is configured to send these when the
426 * firmware passes certain points in processing our TX
427 * Ethernet Queue or if we make an explicit request for one.
428 * We use these updates to determine when we may need to
429 * restart a TX Ethernet Queue which was stopped for lack of
430 * free TX Queue Descriptors ...
432 const struct cpl_sge_egr_update *p = (void *)cpl;
433 unsigned int qid = EGR_QID(be32_to_cpu(p->opcode_qid));
434 struct sge *s = &adapter->sge;
435 struct sge_txq *tq;
436 struct sge_eth_txq *txq;
437 unsigned int eq_idx;
440 * Perform sanity checking on the Queue ID to make sure it
441 * really refers to one of our TX Ethernet Egress Queues which
442 * is active and matches the queue's ID. None of these error
443 * conditions should ever happen so we may want to either make
444 * them fatal and/or conditionalized under DEBUG.
446 eq_idx = EQ_IDX(s, qid);
447 if (unlikely(eq_idx >= MAX_EGRQ)) {
448 dev_err(adapter->pdev_dev,
449 "Egress Update QID %d out of range\n", qid);
450 break;
452 tq = s->egr_map[eq_idx];
453 if (unlikely(tq == NULL)) {
454 dev_err(adapter->pdev_dev,
455 "Egress Update QID %d TXQ=NULL\n", qid);
456 break;
458 txq = container_of(tq, struct sge_eth_txq, q);
459 if (unlikely(tq->abs_id != qid)) {
460 dev_err(adapter->pdev_dev,
461 "Egress Update QID %d refers to TXQ %d\n",
462 qid, tq->abs_id);
463 break;
467 * Restart a stopped TX Queue which has less than half of its
468 * TX ring in use ...
470 txq->q.restarts++;
471 netif_tx_wake_queue(txq->txq);
472 break;
475 default:
476 dev_err(adapter->pdev_dev,
477 "unexpected CPL %#x on FW event queue\n", opcode);
480 return 0;
484 * Allocate SGE TX/RX response queues. Determine how many sets of SGE queues
485 * to use and initializes them. We support multiple "Queue Sets" per port if
486 * we have MSI-X, otherwise just one queue set per port.
488 static int setup_sge_queues(struct adapter *adapter)
490 struct sge *s = &adapter->sge;
491 int err, pidx, msix;
494 * Clear "Queue Set" Free List Starving and TX Queue Mapping Error
495 * state.
497 bitmap_zero(s->starving_fl, MAX_EGRQ);
500 * If we're using MSI interrupt mode we need to set up a "forwarded
501 * interrupt" queue which we'll set up with our MSI vector. The rest
502 * of the ingress queues will be set up to forward their interrupts to
503 * this queue ... This must be first since t4vf_sge_alloc_rxq() uses
504 * the intrq's queue ID as the interrupt forwarding queue for the
505 * subsequent calls ...
507 if (adapter->flags & USING_MSI) {
508 err = t4vf_sge_alloc_rxq(adapter, &s->intrq, false,
509 adapter->port[0], 0, NULL, NULL);
510 if (err)
511 goto err_free_queues;
515 * Allocate our ingress queue for asynchronous firmware messages.
517 err = t4vf_sge_alloc_rxq(adapter, &s->fw_evtq, true, adapter->port[0],
518 MSIX_FW, NULL, fwevtq_handler);
519 if (err)
520 goto err_free_queues;
523 * Allocate each "port"'s initial Queue Sets. These can be changed
524 * later on ... up to the point where any interface on the adapter is
525 * brought up at which point lots of things get nailed down
526 * permanently ...
528 msix = MSIX_IQFLINT;
529 for_each_port(adapter, pidx) {
530 struct net_device *dev = adapter->port[pidx];
531 struct port_info *pi = netdev_priv(dev);
532 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset];
533 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset];
534 int qs;
536 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
537 err = t4vf_sge_alloc_rxq(adapter, &rxq->rspq, false,
538 dev, msix++,
539 &rxq->fl, t4vf_ethrx_handler);
540 if (err)
541 goto err_free_queues;
543 err = t4vf_sge_alloc_eth_txq(adapter, txq, dev,
544 netdev_get_tx_queue(dev, qs),
545 s->fw_evtq.cntxt_id);
546 if (err)
547 goto err_free_queues;
549 rxq->rspq.idx = qs;
550 memset(&rxq->stats, 0, sizeof(rxq->stats));
555 * Create the reverse mappings for the queues.
557 s->egr_base = s->ethtxq[0].q.abs_id - s->ethtxq[0].q.cntxt_id;
558 s->ingr_base = s->ethrxq[0].rspq.abs_id - s->ethrxq[0].rspq.cntxt_id;
559 IQ_MAP(s, s->fw_evtq.abs_id) = &s->fw_evtq;
560 for_each_port(adapter, pidx) {
561 struct net_device *dev = adapter->port[pidx];
562 struct port_info *pi = netdev_priv(dev);
563 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset];
564 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset];
565 int qs;
567 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
568 IQ_MAP(s, rxq->rspq.abs_id) = &rxq->rspq;
569 EQ_MAP(s, txq->q.abs_id) = &txq->q;
572 * The FW_IQ_CMD doesn't return the Absolute Queue IDs
573 * for Free Lists but since all of the Egress Queues
574 * (including Free Lists) have Relative Queue IDs
575 * which are computed as Absolute - Base Queue ID, we
576 * can synthesize the Absolute Queue IDs for the Free
577 * Lists. This is useful for debugging purposes when
578 * we want to dump Queue Contexts via the PF Driver.
580 rxq->fl.abs_id = rxq->fl.cntxt_id + s->egr_base;
581 EQ_MAP(s, rxq->fl.abs_id) = &rxq->fl;
584 return 0;
586 err_free_queues:
587 t4vf_free_sge_resources(adapter);
588 return err;
592 * Set up Receive Side Scaling (RSS) to distribute packets to multiple receive
593 * queues. We configure the RSS CPU lookup table to distribute to the number
594 * of HW receive queues, and the response queue lookup table to narrow that
595 * down to the response queues actually configured for each "port" (Virtual
596 * Interface). We always configure the RSS mapping for all ports since the
597 * mapping table has plenty of entries.
599 static int setup_rss(struct adapter *adapter)
601 int pidx;
603 for_each_port(adapter, pidx) {
604 struct port_info *pi = adap2pinfo(adapter, pidx);
605 struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset];
606 u16 rss[MAX_PORT_QSETS];
607 int qs, err;
609 for (qs = 0; qs < pi->nqsets; qs++)
610 rss[qs] = rxq[qs].rspq.abs_id;
612 err = t4vf_config_rss_range(adapter, pi->viid,
613 0, pi->rss_size, rss, pi->nqsets);
614 if (err)
615 return err;
618 * Perform Global RSS Mode-specific initialization.
620 switch (adapter->params.rss.mode) {
621 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL:
623 * If Tunnel All Lookup isn't specified in the global
624 * RSS Configuration, then we need to specify a
625 * default Ingress Queue for any ingress packets which
626 * aren't hashed. We'll use our first ingress queue
627 * ...
629 if (!adapter->params.rss.u.basicvirtual.tnlalllookup) {
630 union rss_vi_config config;
631 err = t4vf_read_rss_vi_config(adapter,
632 pi->viid,
633 &config);
634 if (err)
635 return err;
636 config.basicvirtual.defaultq =
637 rxq[0].rspq.abs_id;
638 err = t4vf_write_rss_vi_config(adapter,
639 pi->viid,
640 &config);
641 if (err)
642 return err;
644 break;
648 return 0;
652 * Bring the adapter up. Called whenever we go from no "ports" open to having
653 * one open. This function performs the actions necessary to make an adapter
654 * operational, such as completing the initialization of HW modules, and
655 * enabling interrupts. Must be called with the rtnl lock held. (Note that
656 * this is called "cxgb_up" in the PF Driver.)
658 static int adapter_up(struct adapter *adapter)
660 int err;
663 * If this is the first time we've been called, perform basic
664 * adapter setup. Once we've done this, many of our adapter
665 * parameters can no longer be changed ...
667 if ((adapter->flags & FULL_INIT_DONE) == 0) {
668 err = setup_sge_queues(adapter);
669 if (err)
670 return err;
671 err = setup_rss(adapter);
672 if (err) {
673 t4vf_free_sge_resources(adapter);
674 return err;
677 if (adapter->flags & USING_MSIX)
678 name_msix_vecs(adapter);
679 adapter->flags |= FULL_INIT_DONE;
683 * Acquire our interrupt resources. We only support MSI-X and MSI.
685 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0);
686 if (adapter->flags & USING_MSIX)
687 err = request_msix_queue_irqs(adapter);
688 else
689 err = request_irq(adapter->pdev->irq,
690 t4vf_intr_handler(adapter), 0,
691 adapter->name, adapter);
692 if (err) {
693 dev_err(adapter->pdev_dev, "request_irq failed, err %d\n",
694 err);
695 return err;
699 * Enable NAPI ingress processing and return success.
701 enable_rx(adapter);
702 t4vf_sge_start(adapter);
703 return 0;
707 * Bring the adapter down. Called whenever the last "port" (Virtual
708 * Interface) closed. (Note that this routine is called "cxgb_down" in the PF
709 * Driver.)
711 static void adapter_down(struct adapter *adapter)
714 * Free interrupt resources.
716 if (adapter->flags & USING_MSIX)
717 free_msix_queue_irqs(adapter);
718 else
719 free_irq(adapter->pdev->irq, adapter);
722 * Wait for NAPI handlers to finish.
724 quiesce_rx(adapter);
728 * Start up a net device.
730 static int cxgb4vf_open(struct net_device *dev)
732 int err;
733 struct port_info *pi = netdev_priv(dev);
734 struct adapter *adapter = pi->adapter;
737 * If this is the first interface that we're opening on the "adapter",
738 * bring the "adapter" up now.
740 if (adapter->open_device_map == 0) {
741 err = adapter_up(adapter);
742 if (err)
743 return err;
747 * Note that this interface is up and start everything up ...
749 netif_set_real_num_tx_queues(dev, pi->nqsets);
750 err = netif_set_real_num_rx_queues(dev, pi->nqsets);
751 if (err)
752 goto err_unwind;
753 err = link_start(dev);
754 if (err)
755 goto err_unwind;
757 netif_tx_start_all_queues(dev);
758 set_bit(pi->port_id, &adapter->open_device_map);
759 return 0;
761 err_unwind:
762 if (adapter->open_device_map == 0)
763 adapter_down(adapter);
764 return err;
768 * Shut down a net device. This routine is called "cxgb_close" in the PF
769 * Driver ...
771 static int cxgb4vf_stop(struct net_device *dev)
773 struct port_info *pi = netdev_priv(dev);
774 struct adapter *adapter = pi->adapter;
776 netif_tx_stop_all_queues(dev);
777 netif_carrier_off(dev);
778 t4vf_enable_vi(adapter, pi->viid, false, false);
779 pi->link_cfg.link_ok = 0;
781 clear_bit(pi->port_id, &adapter->open_device_map);
782 if (adapter->open_device_map == 0)
783 adapter_down(adapter);
784 return 0;
788 * Translate our basic statistics into the standard "ifconfig" statistics.
790 static struct net_device_stats *cxgb4vf_get_stats(struct net_device *dev)
792 struct t4vf_port_stats stats;
793 struct port_info *pi = netdev2pinfo(dev);
794 struct adapter *adapter = pi->adapter;
795 struct net_device_stats *ns = &dev->stats;
796 int err;
798 spin_lock(&adapter->stats_lock);
799 err = t4vf_get_port_stats(adapter, pi->pidx, &stats);
800 spin_unlock(&adapter->stats_lock);
802 memset(ns, 0, sizeof(*ns));
803 if (err)
804 return ns;
806 ns->tx_bytes = (stats.tx_bcast_bytes + stats.tx_mcast_bytes +
807 stats.tx_ucast_bytes + stats.tx_offload_bytes);
808 ns->tx_packets = (stats.tx_bcast_frames + stats.tx_mcast_frames +
809 stats.tx_ucast_frames + stats.tx_offload_frames);
810 ns->rx_bytes = (stats.rx_bcast_bytes + stats.rx_mcast_bytes +
811 stats.rx_ucast_bytes);
812 ns->rx_packets = (stats.rx_bcast_frames + stats.rx_mcast_frames +
813 stats.rx_ucast_frames);
814 ns->multicast = stats.rx_mcast_frames;
815 ns->tx_errors = stats.tx_drop_frames;
816 ns->rx_errors = stats.rx_err_frames;
818 return ns;
822 * Collect up to maxaddrs worth of a netdevice's unicast addresses, starting
823 * at a specified offset within the list, into an array of addrss pointers and
824 * return the number collected.
826 static inline unsigned int collect_netdev_uc_list_addrs(const struct net_device *dev,
827 const u8 **addr,
828 unsigned int offset,
829 unsigned int maxaddrs)
831 unsigned int index = 0;
832 unsigned int naddr = 0;
833 const struct netdev_hw_addr *ha;
835 for_each_dev_addr(dev, ha)
836 if (index++ >= offset) {
837 addr[naddr++] = ha->addr;
838 if (naddr >= maxaddrs)
839 break;
841 return naddr;
845 * Collect up to maxaddrs worth of a netdevice's multicast addresses, starting
846 * at a specified offset within the list, into an array of addrss pointers and
847 * return the number collected.
849 static inline unsigned int collect_netdev_mc_list_addrs(const struct net_device *dev,
850 const u8 **addr,
851 unsigned int offset,
852 unsigned int maxaddrs)
854 unsigned int index = 0;
855 unsigned int naddr = 0;
856 const struct netdev_hw_addr *ha;
858 netdev_for_each_mc_addr(ha, dev)
859 if (index++ >= offset) {
860 addr[naddr++] = ha->addr;
861 if (naddr >= maxaddrs)
862 break;
864 return naddr;
868 * Configure the exact and hash address filters to handle a port's multicast
869 * and secondary unicast MAC addresses.
871 static int set_addr_filters(const struct net_device *dev, bool sleep)
873 u64 mhash = 0;
874 u64 uhash = 0;
875 bool free = true;
876 unsigned int offset, naddr;
877 const u8 *addr[7];
878 int ret;
879 const struct port_info *pi = netdev_priv(dev);
881 /* first do the secondary unicast addresses */
882 for (offset = 0; ; offset += naddr) {
883 naddr = collect_netdev_uc_list_addrs(dev, addr, offset,
884 ARRAY_SIZE(addr));
885 if (naddr == 0)
886 break;
888 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
889 naddr, addr, NULL, &uhash, sleep);
890 if (ret < 0)
891 return ret;
893 free = false;
896 /* next set up the multicast addresses */
897 for (offset = 0; ; offset += naddr) {
898 naddr = collect_netdev_mc_list_addrs(dev, addr, offset,
899 ARRAY_SIZE(addr));
900 if (naddr == 0)
901 break;
903 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
904 naddr, addr, NULL, &mhash, sleep);
905 if (ret < 0)
906 return ret;
907 free = false;
910 return t4vf_set_addr_hash(pi->adapter, pi->viid, uhash != 0,
911 uhash | mhash, sleep);
915 * Set RX properties of a port, such as promiscruity, address filters, and MTU.
916 * If @mtu is -1 it is left unchanged.
918 static int set_rxmode(struct net_device *dev, int mtu, bool sleep_ok)
920 int ret;
921 struct port_info *pi = netdev_priv(dev);
923 ret = set_addr_filters(dev, sleep_ok);
924 if (ret == 0)
925 ret = t4vf_set_rxmode(pi->adapter, pi->viid, -1,
926 (dev->flags & IFF_PROMISC) != 0,
927 (dev->flags & IFF_ALLMULTI) != 0,
928 1, -1, sleep_ok);
929 return ret;
933 * Set the current receive modes on the device.
935 static void cxgb4vf_set_rxmode(struct net_device *dev)
937 /* unfortunately we can't return errors to the stack */
938 set_rxmode(dev, -1, false);
942 * Find the entry in the interrupt holdoff timer value array which comes
943 * closest to the specified interrupt holdoff value.
945 static int closest_timer(const struct sge *s, int us)
947 int i, timer_idx = 0, min_delta = INT_MAX;
949 for (i = 0; i < ARRAY_SIZE(s->timer_val); i++) {
950 int delta = us - s->timer_val[i];
951 if (delta < 0)
952 delta = -delta;
953 if (delta < min_delta) {
954 min_delta = delta;
955 timer_idx = i;
958 return timer_idx;
961 static int closest_thres(const struct sge *s, int thres)
963 int i, delta, pktcnt_idx = 0, min_delta = INT_MAX;
965 for (i = 0; i < ARRAY_SIZE(s->counter_val); i++) {
966 delta = thres - s->counter_val[i];
967 if (delta < 0)
968 delta = -delta;
969 if (delta < min_delta) {
970 min_delta = delta;
971 pktcnt_idx = i;
974 return pktcnt_idx;
978 * Return a queue's interrupt hold-off time in us. 0 means no timer.
980 static unsigned int qtimer_val(const struct adapter *adapter,
981 const struct sge_rspq *rspq)
983 unsigned int timer_idx = QINTR_TIMER_IDX_GET(rspq->intr_params);
985 return timer_idx < SGE_NTIMERS
986 ? adapter->sge.timer_val[timer_idx]
987 : 0;
991 * set_rxq_intr_params - set a queue's interrupt holdoff parameters
992 * @adapter: the adapter
993 * @rspq: the RX response queue
994 * @us: the hold-off time in us, or 0 to disable timer
995 * @cnt: the hold-off packet count, or 0 to disable counter
997 * Sets an RX response queue's interrupt hold-off time and packet count.
998 * At least one of the two needs to be enabled for the queue to generate
999 * interrupts.
1001 static int set_rxq_intr_params(struct adapter *adapter, struct sge_rspq *rspq,
1002 unsigned int us, unsigned int cnt)
1004 unsigned int timer_idx;
1007 * If both the interrupt holdoff timer and count are specified as
1008 * zero, default to a holdoff count of 1 ...
1010 if ((us | cnt) == 0)
1011 cnt = 1;
1014 * If an interrupt holdoff count has been specified, then find the
1015 * closest configured holdoff count and use that. If the response
1016 * queue has already been created, then update its queue context
1017 * parameters ...
1019 if (cnt) {
1020 int err;
1021 u32 v, pktcnt_idx;
1023 pktcnt_idx = closest_thres(&adapter->sge, cnt);
1024 if (rspq->desc && rspq->pktcnt_idx != pktcnt_idx) {
1025 v = FW_PARAMS_MNEM(FW_PARAMS_MNEM_DMAQ) |
1026 FW_PARAMS_PARAM_X(
1027 FW_PARAMS_PARAM_DMAQ_IQ_INTCNTTHRESH) |
1028 FW_PARAMS_PARAM_YZ(rspq->cntxt_id);
1029 err = t4vf_set_params(adapter, 1, &v, &pktcnt_idx);
1030 if (err)
1031 return err;
1033 rspq->pktcnt_idx = pktcnt_idx;
1037 * Compute the closest holdoff timer index from the supplied holdoff
1038 * timer value.
1040 timer_idx = (us == 0
1041 ? SGE_TIMER_RSTRT_CNTR
1042 : closest_timer(&adapter->sge, us));
1045 * Update the response queue's interrupt coalescing parameters and
1046 * return success.
1048 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
1049 (cnt > 0 ? QINTR_CNT_EN : 0));
1050 return 0;
1054 * Return a version number to identify the type of adapter. The scheme is:
1055 * - bits 0..9: chip version
1056 * - bits 10..15: chip revision
1058 static inline unsigned int mk_adap_vers(const struct adapter *adapter)
1061 * Chip version 4, revision 0x3f (cxgb4vf).
1063 return 4 | (0x3f << 10);
1067 * Execute the specified ioctl command.
1069 static int cxgb4vf_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1071 int ret = 0;
1073 switch (cmd) {
1075 * The VF Driver doesn't have access to any of the other
1076 * common Ethernet device ioctl()'s (like reading/writing
1077 * PHY registers, etc.
1080 default:
1081 ret = -EOPNOTSUPP;
1082 break;
1084 return ret;
1088 * Change the device's MTU.
1090 static int cxgb4vf_change_mtu(struct net_device *dev, int new_mtu)
1092 int ret;
1093 struct port_info *pi = netdev_priv(dev);
1095 /* accommodate SACK */
1096 if (new_mtu < 81)
1097 return -EINVAL;
1099 ret = t4vf_set_rxmode(pi->adapter, pi->viid, new_mtu,
1100 -1, -1, -1, -1, true);
1101 if (!ret)
1102 dev->mtu = new_mtu;
1103 return ret;
1107 * Change the devices MAC address.
1109 static int cxgb4vf_set_mac_addr(struct net_device *dev, void *_addr)
1111 int ret;
1112 struct sockaddr *addr = _addr;
1113 struct port_info *pi = netdev_priv(dev);
1115 if (!is_valid_ether_addr(addr->sa_data))
1116 return -EINVAL;
1118 ret = t4vf_change_mac(pi->adapter, pi->viid, pi->xact_addr_filt,
1119 addr->sa_data, true);
1120 if (ret < 0)
1121 return ret;
1123 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1124 pi->xact_addr_filt = ret;
1125 return 0;
1128 #ifdef CONFIG_NET_POLL_CONTROLLER
1130 * Poll all of our receive queues. This is called outside of normal interrupt
1131 * context.
1133 static void cxgb4vf_poll_controller(struct net_device *dev)
1135 struct port_info *pi = netdev_priv(dev);
1136 struct adapter *adapter = pi->adapter;
1138 if (adapter->flags & USING_MSIX) {
1139 struct sge_eth_rxq *rxq;
1140 int nqsets;
1142 rxq = &adapter->sge.ethrxq[pi->first_qset];
1143 for (nqsets = pi->nqsets; nqsets; nqsets--) {
1144 t4vf_sge_intr_msix(0, &rxq->rspq);
1145 rxq++;
1147 } else
1148 t4vf_intr_handler(adapter)(0, adapter);
1150 #endif
1153 * Ethtool operations.
1154 * ===================
1156 * Note that we don't support any ethtool operations which change the physical
1157 * state of the port to which we're linked.
1161 * Return current port link settings.
1163 static int cxgb4vf_get_settings(struct net_device *dev,
1164 struct ethtool_cmd *cmd)
1166 const struct port_info *pi = netdev_priv(dev);
1168 cmd->supported = pi->link_cfg.supported;
1169 cmd->advertising = pi->link_cfg.advertising;
1170 ethtool_cmd_speed_set(cmd,
1171 netif_carrier_ok(dev) ? pi->link_cfg.speed : -1);
1172 cmd->duplex = DUPLEX_FULL;
1174 cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
1175 cmd->phy_address = pi->port_id;
1176 cmd->transceiver = XCVR_EXTERNAL;
1177 cmd->autoneg = pi->link_cfg.autoneg;
1178 cmd->maxtxpkt = 0;
1179 cmd->maxrxpkt = 0;
1180 return 0;
1184 * Return our driver information.
1186 static void cxgb4vf_get_drvinfo(struct net_device *dev,
1187 struct ethtool_drvinfo *drvinfo)
1189 struct adapter *adapter = netdev2adap(dev);
1191 strcpy(drvinfo->driver, KBUILD_MODNAME);
1192 strcpy(drvinfo->version, DRV_VERSION);
1193 strcpy(drvinfo->bus_info, pci_name(to_pci_dev(dev->dev.parent)));
1194 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1195 "%u.%u.%u.%u, TP %u.%u.%u.%u",
1196 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.fwrev),
1197 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.fwrev),
1198 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.fwrev),
1199 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.fwrev),
1200 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.tprev),
1201 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.tprev),
1202 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.tprev),
1203 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.tprev));
1207 * Return current adapter message level.
1209 static u32 cxgb4vf_get_msglevel(struct net_device *dev)
1211 return netdev2adap(dev)->msg_enable;
1215 * Set current adapter message level.
1217 static void cxgb4vf_set_msglevel(struct net_device *dev, u32 msglevel)
1219 netdev2adap(dev)->msg_enable = msglevel;
1223 * Return the device's current Queue Set ring size parameters along with the
1224 * allowed maximum values. Since ethtool doesn't understand the concept of
1225 * multi-queue devices, we just return the current values associated with the
1226 * first Queue Set.
1228 static void cxgb4vf_get_ringparam(struct net_device *dev,
1229 struct ethtool_ringparam *rp)
1231 const struct port_info *pi = netdev_priv(dev);
1232 const struct sge *s = &pi->adapter->sge;
1234 rp->rx_max_pending = MAX_RX_BUFFERS;
1235 rp->rx_mini_max_pending = MAX_RSPQ_ENTRIES;
1236 rp->rx_jumbo_max_pending = 0;
1237 rp->tx_max_pending = MAX_TXQ_ENTRIES;
1239 rp->rx_pending = s->ethrxq[pi->first_qset].fl.size - MIN_FL_RESID;
1240 rp->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size;
1241 rp->rx_jumbo_pending = 0;
1242 rp->tx_pending = s->ethtxq[pi->first_qset].q.size;
1246 * Set the Queue Set ring size parameters for the device. Again, since
1247 * ethtool doesn't allow for the concept of multiple queues per device, we'll
1248 * apply these new values across all of the Queue Sets associated with the
1249 * device -- after vetting them of course!
1251 static int cxgb4vf_set_ringparam(struct net_device *dev,
1252 struct ethtool_ringparam *rp)
1254 const struct port_info *pi = netdev_priv(dev);
1255 struct adapter *adapter = pi->adapter;
1256 struct sge *s = &adapter->sge;
1257 int qs;
1259 if (rp->rx_pending > MAX_RX_BUFFERS ||
1260 rp->rx_jumbo_pending ||
1261 rp->tx_pending > MAX_TXQ_ENTRIES ||
1262 rp->rx_mini_pending > MAX_RSPQ_ENTRIES ||
1263 rp->rx_mini_pending < MIN_RSPQ_ENTRIES ||
1264 rp->rx_pending < MIN_FL_ENTRIES ||
1265 rp->tx_pending < MIN_TXQ_ENTRIES)
1266 return -EINVAL;
1268 if (adapter->flags & FULL_INIT_DONE)
1269 return -EBUSY;
1271 for (qs = pi->first_qset; qs < pi->first_qset + pi->nqsets; qs++) {
1272 s->ethrxq[qs].fl.size = rp->rx_pending + MIN_FL_RESID;
1273 s->ethrxq[qs].rspq.size = rp->rx_mini_pending;
1274 s->ethtxq[qs].q.size = rp->tx_pending;
1276 return 0;
1280 * Return the interrupt holdoff timer and count for the first Queue Set on the
1281 * device. Our extension ioctl() (the cxgbtool interface) allows the
1282 * interrupt holdoff timer to be read on all of the device's Queue Sets.
1284 static int cxgb4vf_get_coalesce(struct net_device *dev,
1285 struct ethtool_coalesce *coalesce)
1287 const struct port_info *pi = netdev_priv(dev);
1288 const struct adapter *adapter = pi->adapter;
1289 const struct sge_rspq *rspq = &adapter->sge.ethrxq[pi->first_qset].rspq;
1291 coalesce->rx_coalesce_usecs = qtimer_val(adapter, rspq);
1292 coalesce->rx_max_coalesced_frames =
1293 ((rspq->intr_params & QINTR_CNT_EN)
1294 ? adapter->sge.counter_val[rspq->pktcnt_idx]
1295 : 0);
1296 return 0;
1300 * Set the RX interrupt holdoff timer and count for the first Queue Set on the
1301 * interface. Our extension ioctl() (the cxgbtool interface) allows us to set
1302 * the interrupt holdoff timer on any of the device's Queue Sets.
1304 static int cxgb4vf_set_coalesce(struct net_device *dev,
1305 struct ethtool_coalesce *coalesce)
1307 const struct port_info *pi = netdev_priv(dev);
1308 struct adapter *adapter = pi->adapter;
1310 return set_rxq_intr_params(adapter,
1311 &adapter->sge.ethrxq[pi->first_qset].rspq,
1312 coalesce->rx_coalesce_usecs,
1313 coalesce->rx_max_coalesced_frames);
1317 * Report current port link pause parameter settings.
1319 static void cxgb4vf_get_pauseparam(struct net_device *dev,
1320 struct ethtool_pauseparam *pauseparam)
1322 struct port_info *pi = netdev_priv(dev);
1324 pauseparam->autoneg = (pi->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
1325 pauseparam->rx_pause = (pi->link_cfg.fc & PAUSE_RX) != 0;
1326 pauseparam->tx_pause = (pi->link_cfg.fc & PAUSE_TX) != 0;
1330 * Identify the port by blinking the port's LED.
1332 static int cxgb4vf_phys_id(struct net_device *dev,
1333 enum ethtool_phys_id_state state)
1335 unsigned int val;
1336 struct port_info *pi = netdev_priv(dev);
1338 if (state == ETHTOOL_ID_ACTIVE)
1339 val = 0xffff;
1340 else if (state == ETHTOOL_ID_INACTIVE)
1341 val = 0;
1342 else
1343 return -EINVAL;
1345 return t4vf_identify_port(pi->adapter, pi->viid, val);
1349 * Port stats maintained per queue of the port.
1351 struct queue_port_stats {
1352 u64 tso;
1353 u64 tx_csum;
1354 u64 rx_csum;
1355 u64 vlan_ex;
1356 u64 vlan_ins;
1357 u64 lro_pkts;
1358 u64 lro_merged;
1362 * Strings for the ETH_SS_STATS statistics set ("ethtool -S"). Note that
1363 * these need to match the order of statistics returned by
1364 * t4vf_get_port_stats().
1366 static const char stats_strings[][ETH_GSTRING_LEN] = {
1368 * These must match the layout of the t4vf_port_stats structure.
1370 "TxBroadcastBytes ",
1371 "TxBroadcastFrames ",
1372 "TxMulticastBytes ",
1373 "TxMulticastFrames ",
1374 "TxUnicastBytes ",
1375 "TxUnicastFrames ",
1376 "TxDroppedFrames ",
1377 "TxOffloadBytes ",
1378 "TxOffloadFrames ",
1379 "RxBroadcastBytes ",
1380 "RxBroadcastFrames ",
1381 "RxMulticastBytes ",
1382 "RxMulticastFrames ",
1383 "RxUnicastBytes ",
1384 "RxUnicastFrames ",
1385 "RxErrorFrames ",
1388 * These are accumulated per-queue statistics and must match the
1389 * order of the fields in the queue_port_stats structure.
1391 "TSO ",
1392 "TxCsumOffload ",
1393 "RxCsumGood ",
1394 "VLANextractions ",
1395 "VLANinsertions ",
1396 "GROPackets ",
1397 "GROMerged ",
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;
1447 stats->lro_pkts += rxq->stats.lro_pkts;
1448 stats->lro_merged += rxq->stats.lro_merged;
1453 * Return the ETH_SS_STATS statistics set.
1455 static void cxgb4vf_get_ethtool_stats(struct net_device *dev,
1456 struct ethtool_stats *stats,
1457 u64 *data)
1459 struct port_info *pi = netdev2pinfo(dev);
1460 struct adapter *adapter = pi->adapter;
1461 int err = t4vf_get_port_stats(adapter, pi->pidx,
1462 (struct t4vf_port_stats *)data);
1463 if (err)
1464 memset(data, 0, sizeof(struct t4vf_port_stats));
1466 data += sizeof(struct t4vf_port_stats) / sizeof(u64);
1467 collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
1471 * Return the size of our register map.
1473 static int cxgb4vf_get_regs_len(struct net_device *dev)
1475 return T4VF_REGMAP_SIZE;
1479 * Dump a block of registers, start to end inclusive, into a buffer.
1481 static void reg_block_dump(struct adapter *adapter, void *regbuf,
1482 unsigned int start, unsigned int end)
1484 u32 *bp = regbuf + start - T4VF_REGMAP_START;
1486 for ( ; start <= end; start += sizeof(u32)) {
1488 * Avoid reading the Mailbox Control register since that
1489 * can trigger a Mailbox Ownership Arbitration cycle and
1490 * interfere with communication with the firmware.
1492 if (start == T4VF_CIM_BASE_ADDR + CIM_VF_EXT_MAILBOX_CTRL)
1493 *bp++ = 0xffff;
1494 else
1495 *bp++ = t4_read_reg(adapter, start);
1500 * Copy our entire register map into the provided buffer.
1502 static void cxgb4vf_get_regs(struct net_device *dev,
1503 struct ethtool_regs *regs,
1504 void *regbuf)
1506 struct adapter *adapter = netdev2adap(dev);
1508 regs->version = mk_adap_vers(adapter);
1511 * Fill in register buffer with our register map.
1513 memset(regbuf, 0, T4VF_REGMAP_SIZE);
1515 reg_block_dump(adapter, regbuf,
1516 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_FIRST,
1517 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_LAST);
1518 reg_block_dump(adapter, regbuf,
1519 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_FIRST,
1520 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_LAST);
1521 reg_block_dump(adapter, regbuf,
1522 T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_FIRST,
1523 T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_LAST);
1524 reg_block_dump(adapter, regbuf,
1525 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_FIRST,
1526 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_LAST);
1528 reg_block_dump(adapter, regbuf,
1529 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_FIRST,
1530 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_LAST);
1534 * Report current Wake On LAN settings.
1536 static void cxgb4vf_get_wol(struct net_device *dev,
1537 struct ethtool_wolinfo *wol)
1539 wol->supported = 0;
1540 wol->wolopts = 0;
1541 memset(&wol->sopass, 0, sizeof(wol->sopass));
1545 * TCP Segmentation Offload flags which we support.
1547 #define TSO_FLAGS (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
1549 static struct ethtool_ops cxgb4vf_ethtool_ops = {
1550 .get_settings = cxgb4vf_get_settings,
1551 .get_drvinfo = cxgb4vf_get_drvinfo,
1552 .get_msglevel = cxgb4vf_get_msglevel,
1553 .set_msglevel = cxgb4vf_set_msglevel,
1554 .get_ringparam = cxgb4vf_get_ringparam,
1555 .set_ringparam = cxgb4vf_set_ringparam,
1556 .get_coalesce = cxgb4vf_get_coalesce,
1557 .set_coalesce = cxgb4vf_set_coalesce,
1558 .get_pauseparam = cxgb4vf_get_pauseparam,
1559 .get_link = ethtool_op_get_link,
1560 .get_strings = cxgb4vf_get_strings,
1561 .set_phys_id = cxgb4vf_phys_id,
1562 .get_sset_count = cxgb4vf_get_sset_count,
1563 .get_ethtool_stats = cxgb4vf_get_ethtool_stats,
1564 .get_regs_len = cxgb4vf_get_regs_len,
1565 .get_regs = cxgb4vf_get_regs,
1566 .get_wol = cxgb4vf_get_wol,
1570 * /sys/kernel/debug/cxgb4vf support code and data.
1571 * ================================================
1575 * Show SGE Queue Set information. We display QPL Queues Sets per line.
1577 #define QPL 4
1579 static int sge_qinfo_show(struct seq_file *seq, void *v)
1581 struct adapter *adapter = seq->private;
1582 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1583 int qs, r = (uintptr_t)v - 1;
1585 if (r)
1586 seq_putc(seq, '\n');
1588 #define S3(fmt_spec, s, v) \
1589 do {\
1590 seq_printf(seq, "%-12s", s); \
1591 for (qs = 0; qs < n; ++qs) \
1592 seq_printf(seq, " %16" fmt_spec, v); \
1593 seq_putc(seq, '\n'); \
1594 } while (0)
1595 #define S(s, v) S3("s", s, v)
1596 #define T(s, v) S3("u", s, txq[qs].v)
1597 #define R(s, v) S3("u", s, rxq[qs].v)
1599 if (r < eth_entries) {
1600 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1601 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1602 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1604 S("QType:", "Ethernet");
1605 S("Interface:",
1606 (rxq[qs].rspq.netdev
1607 ? rxq[qs].rspq.netdev->name
1608 : "N/A"));
1609 S3("d", "Port:",
1610 (rxq[qs].rspq.netdev
1611 ? ((struct port_info *)
1612 netdev_priv(rxq[qs].rspq.netdev))->port_id
1613 : -1));
1614 T("TxQ ID:", q.abs_id);
1615 T("TxQ size:", q.size);
1616 T("TxQ inuse:", q.in_use);
1617 T("TxQ PIdx:", q.pidx);
1618 T("TxQ CIdx:", q.cidx);
1619 R("RspQ ID:", rspq.abs_id);
1620 R("RspQ size:", rspq.size);
1621 R("RspQE size:", rspq.iqe_len);
1622 S3("u", "Intr delay:", qtimer_val(adapter, &rxq[qs].rspq));
1623 S3("u", "Intr pktcnt:",
1624 adapter->sge.counter_val[rxq[qs].rspq.pktcnt_idx]);
1625 R("RspQ CIdx:", rspq.cidx);
1626 R("RspQ Gen:", rspq.gen);
1627 R("FL ID:", fl.abs_id);
1628 R("FL size:", fl.size - MIN_FL_RESID);
1629 R("FL avail:", fl.avail);
1630 R("FL PIdx:", fl.pidx);
1631 R("FL CIdx:", fl.cidx);
1632 return 0;
1635 r -= eth_entries;
1636 if (r == 0) {
1637 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1639 seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue");
1640 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id);
1641 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1642 qtimer_val(adapter, evtq));
1643 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1644 adapter->sge.counter_val[evtq->pktcnt_idx]);
1645 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", evtq->cidx);
1646 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen);
1647 } else if (r == 1) {
1648 const struct sge_rspq *intrq = &adapter->sge.intrq;
1650 seq_printf(seq, "%-12s %16s\n", "QType:", "Interrupt Queue");
1651 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", intrq->abs_id);
1652 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1653 qtimer_val(adapter, intrq));
1654 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1655 adapter->sge.counter_val[intrq->pktcnt_idx]);
1656 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", intrq->cidx);
1657 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", intrq->gen);
1660 #undef R
1661 #undef T
1662 #undef S
1663 #undef S3
1665 return 0;
1669 * Return the number of "entries" in our "file". We group the multi-Queue
1670 * sections with QPL Queue Sets per "entry". The sections of the output are:
1672 * Ethernet RX/TX Queue Sets
1673 * Firmware Event Queue
1674 * Forwarded Interrupt Queue (if in MSI mode)
1676 static int sge_queue_entries(const struct adapter *adapter)
1678 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1679 ((adapter->flags & USING_MSI) != 0);
1682 static void *sge_queue_start(struct seq_file *seq, loff_t *pos)
1684 int entries = sge_queue_entries(seq->private);
1686 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1689 static void sge_queue_stop(struct seq_file *seq, void *v)
1693 static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos)
1695 int entries = sge_queue_entries(seq->private);
1697 ++*pos;
1698 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1701 static const struct seq_operations sge_qinfo_seq_ops = {
1702 .start = sge_queue_start,
1703 .next = sge_queue_next,
1704 .stop = sge_queue_stop,
1705 .show = sge_qinfo_show
1708 static int sge_qinfo_open(struct inode *inode, struct file *file)
1710 int res = seq_open(file, &sge_qinfo_seq_ops);
1712 if (!res) {
1713 struct seq_file *seq = file->private_data;
1714 seq->private = inode->i_private;
1716 return res;
1719 static const struct file_operations sge_qinfo_debugfs_fops = {
1720 .owner = THIS_MODULE,
1721 .open = sge_qinfo_open,
1722 .read = seq_read,
1723 .llseek = seq_lseek,
1724 .release = seq_release,
1728 * Show SGE Queue Set statistics. We display QPL Queues Sets per line.
1730 #define QPL 4
1732 static int sge_qstats_show(struct seq_file *seq, void *v)
1734 struct adapter *adapter = seq->private;
1735 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1736 int qs, r = (uintptr_t)v - 1;
1738 if (r)
1739 seq_putc(seq, '\n');
1741 #define S3(fmt, s, v) \
1742 do { \
1743 seq_printf(seq, "%-16s", s); \
1744 for (qs = 0; qs < n; ++qs) \
1745 seq_printf(seq, " %8" fmt, v); \
1746 seq_putc(seq, '\n'); \
1747 } while (0)
1748 #define S(s, v) S3("s", s, v)
1750 #define T3(fmt, s, v) S3(fmt, s, txq[qs].v)
1751 #define T(s, v) T3("lu", s, v)
1753 #define R3(fmt, s, v) S3(fmt, s, rxq[qs].v)
1754 #define R(s, v) R3("lu", s, v)
1756 if (r < eth_entries) {
1757 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1758 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1759 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1761 S("QType:", "Ethernet");
1762 S("Interface:",
1763 (rxq[qs].rspq.netdev
1764 ? rxq[qs].rspq.netdev->name
1765 : "N/A"));
1766 R3("u", "RspQNullInts:", rspq.unhandled_irqs);
1767 R("RxPackets:", stats.pkts);
1768 R("RxCSO:", stats.rx_cso);
1769 R("VLANxtract:", stats.vlan_ex);
1770 R("LROmerged:", stats.lro_merged);
1771 R("LROpackets:", stats.lro_pkts);
1772 R("RxDrops:", stats.rx_drops);
1773 T("TSO:", tso);
1774 T("TxCSO:", tx_cso);
1775 T("VLANins:", vlan_ins);
1776 T("TxQFull:", q.stops);
1777 T("TxQRestarts:", q.restarts);
1778 T("TxMapErr:", mapping_err);
1779 R("FLAllocErr:", fl.alloc_failed);
1780 R("FLLrgAlcErr:", fl.large_alloc_failed);
1781 R("FLStarving:", fl.starving);
1782 return 0;
1785 r -= eth_entries;
1786 if (r == 0) {
1787 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1789 seq_printf(seq, "%-8s %16s\n", "QType:", "FW event queue");
1790 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1791 evtq->unhandled_irqs);
1792 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", evtq->cidx);
1793 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", evtq->gen);
1794 } else if (r == 1) {
1795 const struct sge_rspq *intrq = &adapter->sge.intrq;
1797 seq_printf(seq, "%-8s %16s\n", "QType:", "Interrupt Queue");
1798 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1799 intrq->unhandled_irqs);
1800 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", intrq->cidx);
1801 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", intrq->gen);
1804 #undef R
1805 #undef T
1806 #undef S
1807 #undef R3
1808 #undef T3
1809 #undef S3
1811 return 0;
1815 * Return the number of "entries" in our "file". We group the multi-Queue
1816 * sections with QPL Queue Sets per "entry". The sections of the output are:
1818 * Ethernet RX/TX Queue Sets
1819 * Firmware Event Queue
1820 * Forwarded Interrupt Queue (if in MSI mode)
1822 static int sge_qstats_entries(const struct adapter *adapter)
1824 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1825 ((adapter->flags & USING_MSI) != 0);
1828 static void *sge_qstats_start(struct seq_file *seq, loff_t *pos)
1830 int entries = sge_qstats_entries(seq->private);
1832 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1835 static void sge_qstats_stop(struct seq_file *seq, void *v)
1839 static void *sge_qstats_next(struct seq_file *seq, void *v, loff_t *pos)
1841 int entries = sge_qstats_entries(seq->private);
1843 (*pos)++;
1844 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1847 static const struct seq_operations sge_qstats_seq_ops = {
1848 .start = sge_qstats_start,
1849 .next = sge_qstats_next,
1850 .stop = sge_qstats_stop,
1851 .show = sge_qstats_show
1854 static int sge_qstats_open(struct inode *inode, struct file *file)
1856 int res = seq_open(file, &sge_qstats_seq_ops);
1858 if (res == 0) {
1859 struct seq_file *seq = file->private_data;
1860 seq->private = inode->i_private;
1862 return res;
1865 static const struct file_operations sge_qstats_proc_fops = {
1866 .owner = THIS_MODULE,
1867 .open = sge_qstats_open,
1868 .read = seq_read,
1869 .llseek = seq_lseek,
1870 .release = seq_release,
1874 * Show PCI-E SR-IOV Virtual Function Resource Limits.
1876 static int resources_show(struct seq_file *seq, void *v)
1878 struct adapter *adapter = seq->private;
1879 struct vf_resources *vfres = &adapter->params.vfres;
1881 #define S(desc, fmt, var) \
1882 seq_printf(seq, "%-60s " fmt "\n", \
1883 desc " (" #var "):", vfres->var)
1885 S("Virtual Interfaces", "%d", nvi);
1886 S("Egress Queues", "%d", neq);
1887 S("Ethernet Control", "%d", nethctrl);
1888 S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint);
1889 S("Ingress Queues", "%d", niq);
1890 S("Traffic Class", "%d", tc);
1891 S("Port Access Rights Mask", "%#x", pmask);
1892 S("MAC Address Filters", "%d", nexactf);
1893 S("Firmware Command Read Capabilities", "%#x", r_caps);
1894 S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps);
1896 #undef S
1898 return 0;
1901 static int resources_open(struct inode *inode, struct file *file)
1903 return single_open(file, resources_show, inode->i_private);
1906 static const struct file_operations resources_proc_fops = {
1907 .owner = THIS_MODULE,
1908 .open = resources_open,
1909 .read = seq_read,
1910 .llseek = seq_lseek,
1911 .release = single_release,
1915 * Show Virtual Interfaces.
1917 static int interfaces_show(struct seq_file *seq, void *v)
1919 if (v == SEQ_START_TOKEN) {
1920 seq_puts(seq, "Interface Port VIID\n");
1921 } else {
1922 struct adapter *adapter = seq->private;
1923 int pidx = (uintptr_t)v - 2;
1924 struct net_device *dev = adapter->port[pidx];
1925 struct port_info *pi = netdev_priv(dev);
1927 seq_printf(seq, "%9s %4d %#5x\n",
1928 dev->name, pi->port_id, pi->viid);
1930 return 0;
1933 static inline void *interfaces_get_idx(struct adapter *adapter, loff_t pos)
1935 return pos <= adapter->params.nports
1936 ? (void *)(uintptr_t)(pos + 1)
1937 : NULL;
1940 static void *interfaces_start(struct seq_file *seq, loff_t *pos)
1942 return *pos
1943 ? interfaces_get_idx(seq->private, *pos)
1944 : SEQ_START_TOKEN;
1947 static void *interfaces_next(struct seq_file *seq, void *v, loff_t *pos)
1949 (*pos)++;
1950 return interfaces_get_idx(seq->private, *pos);
1953 static void interfaces_stop(struct seq_file *seq, void *v)
1957 static const struct seq_operations interfaces_seq_ops = {
1958 .start = interfaces_start,
1959 .next = interfaces_next,
1960 .stop = interfaces_stop,
1961 .show = interfaces_show
1964 static int interfaces_open(struct inode *inode, struct file *file)
1966 int res = seq_open(file, &interfaces_seq_ops);
1968 if (res == 0) {
1969 struct seq_file *seq = file->private_data;
1970 seq->private = inode->i_private;
1972 return res;
1975 static const struct file_operations interfaces_proc_fops = {
1976 .owner = THIS_MODULE,
1977 .open = interfaces_open,
1978 .read = seq_read,
1979 .llseek = seq_lseek,
1980 .release = seq_release,
1984 * /sys/kernel/debugfs/cxgb4vf/ files list.
1986 struct cxgb4vf_debugfs_entry {
1987 const char *name; /* name of debugfs node */
1988 mode_t mode; /* file system mode */
1989 const struct file_operations *fops;
1992 static struct cxgb4vf_debugfs_entry debugfs_files[] = {
1993 { "sge_qinfo", S_IRUGO, &sge_qinfo_debugfs_fops },
1994 { "sge_qstats", S_IRUGO, &sge_qstats_proc_fops },
1995 { "resources", S_IRUGO, &resources_proc_fops },
1996 { "interfaces", S_IRUGO, &interfaces_proc_fops },
2000 * Module and device initialization and cleanup code.
2001 * ==================================================
2005 * Set up out /sys/kernel/debug/cxgb4vf sub-nodes. We assume that the
2006 * directory (debugfs_root) has already been set up.
2008 static int __devinit setup_debugfs(struct adapter *adapter)
2010 int i;
2012 BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root));
2015 * Debugfs support is best effort.
2017 for (i = 0; i < ARRAY_SIZE(debugfs_files); i++)
2018 (void)debugfs_create_file(debugfs_files[i].name,
2019 debugfs_files[i].mode,
2020 adapter->debugfs_root,
2021 (void *)adapter,
2022 debugfs_files[i].fops);
2024 return 0;
2028 * Tear down the /sys/kernel/debug/cxgb4vf sub-nodes created above. We leave
2029 * it to our caller to tear down the directory (debugfs_root).
2031 static void cleanup_debugfs(struct adapter *adapter)
2033 BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root));
2036 * Unlike our sister routine cleanup_proc(), we don't need to remove
2037 * individual entries because a call will be made to
2038 * debugfs_remove_recursive(). We just need to clean up any ancillary
2039 * persistent state.
2041 /* nothing to do */
2045 * Perform early "adapter" initialization. This is where we discover what
2046 * adapter parameters we're going to be using and initialize basic adapter
2047 * hardware support.
2049 static int __devinit adap_init0(struct adapter *adapter)
2051 struct vf_resources *vfres = &adapter->params.vfres;
2052 struct sge_params *sge_params = &adapter->params.sge;
2053 struct sge *s = &adapter->sge;
2054 unsigned int ethqsets;
2055 int err;
2058 * Wait for the device to become ready before proceeding ...
2060 err = t4vf_wait_dev_ready(adapter);
2061 if (err) {
2062 dev_err(adapter->pdev_dev, "device didn't become ready:"
2063 " err=%d\n", err);
2064 return err;
2068 * Some environments do not properly handle PCIE FLRs -- e.g. in Linux
2069 * 2.6.31 and later we can't call pci_reset_function() in order to
2070 * issue an FLR because of a self- deadlock on the device semaphore.
2071 * Meanwhile, the OS infrastructure doesn't issue FLRs in all the
2072 * cases where they're needed -- for instance, some versions of KVM
2073 * fail to reset "Assigned Devices" when the VM reboots. Therefore we
2074 * use the firmware based reset in order to reset any per function
2075 * state.
2077 err = t4vf_fw_reset(adapter);
2078 if (err < 0) {
2079 dev_err(adapter->pdev_dev, "FW reset failed: err=%d\n", err);
2080 return err;
2084 * Grab basic operational parameters. These will predominantly have
2085 * been set up by the Physical Function Driver or will be hard coded
2086 * into the adapter. We just have to live with them ... Note that
2087 * we _must_ get our VPD parameters before our SGE parameters because
2088 * we need to know the adapter's core clock from the VPD in order to
2089 * properly decode the SGE Timer Values.
2091 err = t4vf_get_dev_params(adapter);
2092 if (err) {
2093 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2094 " device parameters: err=%d\n", err);
2095 return err;
2097 err = t4vf_get_vpd_params(adapter);
2098 if (err) {
2099 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2100 " VPD parameters: err=%d\n", err);
2101 return err;
2103 err = t4vf_get_sge_params(adapter);
2104 if (err) {
2105 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2106 " SGE parameters: err=%d\n", err);
2107 return err;
2109 err = t4vf_get_rss_glb_config(adapter);
2110 if (err) {
2111 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2112 " RSS parameters: err=%d\n", err);
2113 return err;
2115 if (adapter->params.rss.mode !=
2116 FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
2117 dev_err(adapter->pdev_dev, "unable to operate with global RSS"
2118 " mode %d\n", adapter->params.rss.mode);
2119 return -EINVAL;
2121 err = t4vf_sge_init(adapter);
2122 if (err) {
2123 dev_err(adapter->pdev_dev, "unable to use adapter parameters:"
2124 " err=%d\n", err);
2125 return err;
2129 * Retrieve our RX interrupt holdoff timer values and counter
2130 * threshold values from the SGE parameters.
2132 s->timer_val[0] = core_ticks_to_us(adapter,
2133 TIMERVALUE0_GET(sge_params->sge_timer_value_0_and_1));
2134 s->timer_val[1] = core_ticks_to_us(adapter,
2135 TIMERVALUE1_GET(sge_params->sge_timer_value_0_and_1));
2136 s->timer_val[2] = core_ticks_to_us(adapter,
2137 TIMERVALUE0_GET(sge_params->sge_timer_value_2_and_3));
2138 s->timer_val[3] = core_ticks_to_us(adapter,
2139 TIMERVALUE1_GET(sge_params->sge_timer_value_2_and_3));
2140 s->timer_val[4] = core_ticks_to_us(adapter,
2141 TIMERVALUE0_GET(sge_params->sge_timer_value_4_and_5));
2142 s->timer_val[5] = core_ticks_to_us(adapter,
2143 TIMERVALUE1_GET(sge_params->sge_timer_value_4_and_5));
2145 s->counter_val[0] =
2146 THRESHOLD_0_GET(sge_params->sge_ingress_rx_threshold);
2147 s->counter_val[1] =
2148 THRESHOLD_1_GET(sge_params->sge_ingress_rx_threshold);
2149 s->counter_val[2] =
2150 THRESHOLD_2_GET(sge_params->sge_ingress_rx_threshold);
2151 s->counter_val[3] =
2152 THRESHOLD_3_GET(sge_params->sge_ingress_rx_threshold);
2155 * Grab our Virtual Interface resource allocation, extract the
2156 * features that we're interested in and do a bit of sanity testing on
2157 * what we discover.
2159 err = t4vf_get_vfres(adapter);
2160 if (err) {
2161 dev_err(adapter->pdev_dev, "unable to get virtual interface"
2162 " resources: err=%d\n", err);
2163 return err;
2167 * The number of "ports" which we support is equal to the number of
2168 * Virtual Interfaces with which we've been provisioned.
2170 adapter->params.nports = vfres->nvi;
2171 if (adapter->params.nports > MAX_NPORTS) {
2172 dev_warn(adapter->pdev_dev, "only using %d of %d allowed"
2173 " virtual interfaces\n", MAX_NPORTS,
2174 adapter->params.nports);
2175 adapter->params.nports = MAX_NPORTS;
2179 * We need to reserve a number of the ingress queues with Free List
2180 * and Interrupt capabilities for special interrupt purposes (like
2181 * asynchronous firmware messages, or forwarded interrupts if we're
2182 * using MSI). The rest of the FL/Intr-capable ingress queues will be
2183 * matched up one-for-one with Ethernet/Control egress queues in order
2184 * to form "Queue Sets" which will be aportioned between the "ports".
2185 * For each Queue Set, we'll need the ability to allocate two Egress
2186 * Contexts -- one for the Ingress Queue Free List and one for the TX
2187 * Ethernet Queue.
2189 ethqsets = vfres->niqflint - INGQ_EXTRAS;
2190 if (vfres->nethctrl != ethqsets) {
2191 dev_warn(adapter->pdev_dev, "unequal number of [available]"
2192 " ingress/egress queues (%d/%d); using minimum for"
2193 " number of Queue Sets\n", ethqsets, vfres->nethctrl);
2194 ethqsets = min(vfres->nethctrl, ethqsets);
2196 if (vfres->neq < ethqsets*2) {
2197 dev_warn(adapter->pdev_dev, "Not enough Egress Contexts (%d)"
2198 " to support Queue Sets (%d); reducing allowed Queue"
2199 " Sets\n", vfres->neq, ethqsets);
2200 ethqsets = vfres->neq/2;
2202 if (ethqsets > MAX_ETH_QSETS) {
2203 dev_warn(adapter->pdev_dev, "only using %d of %d allowed Queue"
2204 " Sets\n", MAX_ETH_QSETS, adapter->sge.max_ethqsets);
2205 ethqsets = MAX_ETH_QSETS;
2207 if (vfres->niq != 0 || vfres->neq > ethqsets*2) {
2208 dev_warn(adapter->pdev_dev, "unused resources niq/neq (%d/%d)"
2209 " ignored\n", vfres->niq, vfres->neq - ethqsets*2);
2211 adapter->sge.max_ethqsets = ethqsets;
2214 * Check for various parameter sanity issues. Most checks simply
2215 * result in us using fewer resources than our provissioning but we
2216 * do need at least one "port" with which to work ...
2218 if (adapter->sge.max_ethqsets < adapter->params.nports) {
2219 dev_warn(adapter->pdev_dev, "only using %d of %d available"
2220 " virtual interfaces (too few Queue Sets)\n",
2221 adapter->sge.max_ethqsets, adapter->params.nports);
2222 adapter->params.nports = adapter->sge.max_ethqsets;
2224 if (adapter->params.nports == 0) {
2225 dev_err(adapter->pdev_dev, "no virtual interfaces configured/"
2226 "usable!\n");
2227 return -EINVAL;
2229 return 0;
2232 static inline void init_rspq(struct sge_rspq *rspq, u8 timer_idx,
2233 u8 pkt_cnt_idx, unsigned int size,
2234 unsigned int iqe_size)
2236 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
2237 (pkt_cnt_idx < SGE_NCOUNTERS ? QINTR_CNT_EN : 0));
2238 rspq->pktcnt_idx = (pkt_cnt_idx < SGE_NCOUNTERS
2239 ? pkt_cnt_idx
2240 : 0);
2241 rspq->iqe_len = iqe_size;
2242 rspq->size = size;
2246 * Perform default configuration of DMA queues depending on the number and
2247 * type of ports we found and the number of available CPUs. Most settings can
2248 * be modified by the admin via ethtool and cxgbtool prior to the adapter
2249 * being brought up for the first time.
2251 static void __devinit cfg_queues(struct adapter *adapter)
2253 struct sge *s = &adapter->sge;
2254 int q10g, n10g, qidx, pidx, qs;
2255 size_t iqe_size;
2258 * We should not be called till we know how many Queue Sets we can
2259 * support. In particular, this means that we need to know what kind
2260 * of interrupts we'll be using ...
2262 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0);
2265 * Count the number of 10GbE Virtual Interfaces that we have.
2267 n10g = 0;
2268 for_each_port(adapter, pidx)
2269 n10g += is_10g_port(&adap2pinfo(adapter, pidx)->link_cfg);
2272 * We default to 1 queue per non-10G port and up to # of cores queues
2273 * per 10G port.
2275 if (n10g == 0)
2276 q10g = 0;
2277 else {
2278 int n1g = (adapter->params.nports - n10g);
2279 q10g = (adapter->sge.max_ethqsets - n1g) / n10g;
2280 if (q10g > num_online_cpus())
2281 q10g = num_online_cpus();
2285 * Allocate the "Queue Sets" to the various Virtual Interfaces.
2286 * The layout will be established in setup_sge_queues() when the
2287 * adapter is brough up for the first time.
2289 qidx = 0;
2290 for_each_port(adapter, pidx) {
2291 struct port_info *pi = adap2pinfo(adapter, pidx);
2293 pi->first_qset = qidx;
2294 pi->nqsets = is_10g_port(&pi->link_cfg) ? q10g : 1;
2295 qidx += pi->nqsets;
2297 s->ethqsets = qidx;
2300 * The Ingress Queue Entry Size for our various Response Queues needs
2301 * to be big enough to accommodate the largest message we can receive
2302 * from the chip/firmware; which is 64 bytes ...
2304 iqe_size = 64;
2307 * Set up default Queue Set parameters ... Start off with the
2308 * shortest interrupt holdoff timer.
2310 for (qs = 0; qs < s->max_ethqsets; qs++) {
2311 struct sge_eth_rxq *rxq = &s->ethrxq[qs];
2312 struct sge_eth_txq *txq = &s->ethtxq[qs];
2314 init_rspq(&rxq->rspq, 0, 0, 1024, iqe_size);
2315 rxq->fl.size = 72;
2316 txq->q.size = 1024;
2320 * The firmware event queue is used for link state changes and
2321 * notifications of TX DMA completions.
2323 init_rspq(&s->fw_evtq, SGE_TIMER_RSTRT_CNTR, 0, 512, iqe_size);
2326 * The forwarded interrupt queue is used when we're in MSI interrupt
2327 * mode. In this mode all interrupts associated with RX queues will
2328 * be forwarded to a single queue which we'll associate with our MSI
2329 * interrupt vector. The messages dropped in the forwarded interrupt
2330 * queue will indicate which ingress queue needs servicing ... This
2331 * queue needs to be large enough to accommodate all of the ingress
2332 * queues which are forwarding their interrupt (+1 to prevent the PIDX
2333 * from equalling the CIDX if every ingress queue has an outstanding
2334 * interrupt). The queue doesn't need to be any larger because no
2335 * ingress queue will ever have more than one outstanding interrupt at
2336 * any time ...
2338 init_rspq(&s->intrq, SGE_TIMER_RSTRT_CNTR, 0, MSIX_ENTRIES + 1,
2339 iqe_size);
2343 * Reduce the number of Ethernet queues across all ports to at most n.
2344 * n provides at least one queue per port.
2346 static void __devinit reduce_ethqs(struct adapter *adapter, int n)
2348 int i;
2349 struct port_info *pi;
2352 * While we have too many active Ether Queue Sets, interate across the
2353 * "ports" and reduce their individual Queue Set allocations.
2355 BUG_ON(n < adapter->params.nports);
2356 while (n < adapter->sge.ethqsets)
2357 for_each_port(adapter, i) {
2358 pi = adap2pinfo(adapter, i);
2359 if (pi->nqsets > 1) {
2360 pi->nqsets--;
2361 adapter->sge.ethqsets--;
2362 if (adapter->sge.ethqsets <= n)
2363 break;
2368 * Reassign the starting Queue Sets for each of the "ports" ...
2370 n = 0;
2371 for_each_port(adapter, i) {
2372 pi = adap2pinfo(adapter, i);
2373 pi->first_qset = n;
2374 n += pi->nqsets;
2379 * We need to grab enough MSI-X vectors to cover our interrupt needs. Ideally
2380 * we get a separate MSI-X vector for every "Queue Set" plus any extras we
2381 * need. Minimally we need one for every Virtual Interface plus those needed
2382 * for our "extras". Note that this process may lower the maximum number of
2383 * allowed Queue Sets ...
2385 static int __devinit enable_msix(struct adapter *adapter)
2387 int i, err, want, need;
2388 struct msix_entry entries[MSIX_ENTRIES];
2389 struct sge *s = &adapter->sge;
2391 for (i = 0; i < MSIX_ENTRIES; ++i)
2392 entries[i].entry = i;
2395 * We _want_ enough MSI-X interrupts to cover all of our "Queue Sets"
2396 * plus those needed for our "extras" (for example, the firmware
2397 * message queue). We _need_ at least one "Queue Set" per Virtual
2398 * Interface plus those needed for our "extras". So now we get to see
2399 * if the song is right ...
2401 want = s->max_ethqsets + MSIX_EXTRAS;
2402 need = adapter->params.nports + MSIX_EXTRAS;
2403 while ((err = pci_enable_msix(adapter->pdev, entries, want)) >= need)
2404 want = err;
2406 if (err == 0) {
2407 int nqsets = want - MSIX_EXTRAS;
2408 if (nqsets < s->max_ethqsets) {
2409 dev_warn(adapter->pdev_dev, "only enough MSI-X vectors"
2410 " for %d Queue Sets\n", nqsets);
2411 s->max_ethqsets = nqsets;
2412 if (nqsets < s->ethqsets)
2413 reduce_ethqs(adapter, nqsets);
2415 for (i = 0; i < want; ++i)
2416 adapter->msix_info[i].vec = entries[i].vector;
2417 } else if (err > 0) {
2418 pci_disable_msix(adapter->pdev);
2419 dev_info(adapter->pdev_dev, "only %d MSI-X vectors left,"
2420 " not using MSI-X\n", err);
2422 return err;
2425 #ifdef HAVE_NET_DEVICE_OPS
2426 static const struct net_device_ops cxgb4vf_netdev_ops = {
2427 .ndo_open = cxgb4vf_open,
2428 .ndo_stop = cxgb4vf_stop,
2429 .ndo_start_xmit = t4vf_eth_xmit,
2430 .ndo_get_stats = cxgb4vf_get_stats,
2431 .ndo_set_rx_mode = cxgb4vf_set_rxmode,
2432 .ndo_set_mac_address = cxgb4vf_set_mac_addr,
2433 .ndo_validate_addr = eth_validate_addr,
2434 .ndo_do_ioctl = cxgb4vf_do_ioctl,
2435 .ndo_change_mtu = cxgb4vf_change_mtu,
2436 .ndo_vlan_rx_register = cxgb4vf_vlan_rx_register,
2437 #ifdef CONFIG_NET_POLL_CONTROLLER
2438 .ndo_poll_controller = cxgb4vf_poll_controller,
2439 #endif
2441 #endif
2444 * "Probe" a device: initialize a device and construct all kernel and driver
2445 * state needed to manage the device. This routine is called "init_one" in
2446 * the PF Driver ...
2448 static int __devinit cxgb4vf_pci_probe(struct pci_dev *pdev,
2449 const struct pci_device_id *ent)
2451 static int version_printed;
2453 int pci_using_dac;
2454 int err, pidx;
2455 unsigned int pmask;
2456 struct adapter *adapter;
2457 struct port_info *pi;
2458 struct net_device *netdev;
2461 * Print our driver banner the first time we're called to initialize a
2462 * device.
2464 if (version_printed == 0) {
2465 printk(KERN_INFO "%s - version %s\n", DRV_DESC, DRV_VERSION);
2466 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 netif_carrier_off(netdev);
2602 netdev->irq = pdev->irq;
2604 netdev->hw_features = NETIF_F_SG | TSO_FLAGS |
2605 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2606 NETIF_F_HW_VLAN_TX | NETIF_F_RXCSUM;
2607 netdev->vlan_features = NETIF_F_SG | TSO_FLAGS |
2608 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2609 NETIF_F_HIGHDMA;
2610 netdev->features = netdev->hw_features |
2611 NETIF_F_HW_VLAN_RX;
2612 if (pci_using_dac)
2613 netdev->features |= NETIF_F_HIGHDMA;
2615 #ifdef HAVE_NET_DEVICE_OPS
2616 netdev->netdev_ops = &cxgb4vf_netdev_ops;
2617 #else
2618 netdev->vlan_rx_register = cxgb4vf_vlan_rx_register;
2619 netdev->open = cxgb4vf_open;
2620 netdev->stop = cxgb4vf_stop;
2621 netdev->hard_start_xmit = t4vf_eth_xmit;
2622 netdev->get_stats = cxgb4vf_get_stats;
2623 netdev->set_rx_mode = cxgb4vf_set_rxmode;
2624 netdev->do_ioctl = cxgb4vf_do_ioctl;
2625 netdev->change_mtu = cxgb4vf_change_mtu;
2626 netdev->set_mac_address = cxgb4vf_set_mac_addr;
2627 #ifdef CONFIG_NET_POLL_CONTROLLER
2628 netdev->poll_controller = cxgb4vf_poll_controller;
2629 #endif
2630 #endif
2631 SET_ETHTOOL_OPS(netdev, &cxgb4vf_ethtool_ops);
2634 * Initialize the hardware/software state for the port.
2636 err = t4vf_port_init(adapter, pidx);
2637 if (err) {
2638 dev_err(&pdev->dev, "cannot initialize port %d\n",
2639 pidx);
2640 goto err_free_dev;
2645 * The "card" is now ready to go. If any errors occur during device
2646 * registration we do not fail the whole "card" but rather proceed
2647 * only with the ports we manage to register successfully. However we
2648 * must register at least one net device.
2650 for_each_port(adapter, pidx) {
2651 netdev = adapter->port[pidx];
2652 if (netdev == NULL)
2653 continue;
2655 err = register_netdev(netdev);
2656 if (err) {
2657 dev_warn(&pdev->dev, "cannot register net device %s,"
2658 " skipping\n", netdev->name);
2659 continue;
2662 set_bit(pidx, &adapter->registered_device_map);
2664 if (adapter->registered_device_map == 0) {
2665 dev_err(&pdev->dev, "could not register any net devices\n");
2666 goto err_free_dev;
2670 * Set up our debugfs entries.
2672 if (!IS_ERR_OR_NULL(cxgb4vf_debugfs_root)) {
2673 adapter->debugfs_root =
2674 debugfs_create_dir(pci_name(pdev),
2675 cxgb4vf_debugfs_root);
2676 if (IS_ERR_OR_NULL(adapter->debugfs_root))
2677 dev_warn(&pdev->dev, "could not create debugfs"
2678 " directory");
2679 else
2680 setup_debugfs(adapter);
2684 * See what interrupts we'll be using. If we've been configured to
2685 * use MSI-X interrupts, try to enable them but fall back to using
2686 * MSI interrupts if we can't enable MSI-X interrupts. If we can't
2687 * get MSI interrupts we bail with the error.
2689 if (msi == MSI_MSIX && enable_msix(adapter) == 0)
2690 adapter->flags |= USING_MSIX;
2691 else {
2692 err = pci_enable_msi(pdev);
2693 if (err) {
2694 dev_err(&pdev->dev, "Unable to allocate %s interrupts;"
2695 " err=%d\n",
2696 msi == MSI_MSIX ? "MSI-X or MSI" : "MSI", err);
2697 goto err_free_debugfs;
2699 adapter->flags |= USING_MSI;
2703 * Now that we know how many "ports" we have and what their types are,
2704 * and how many Queue Sets we can support, we can configure our queue
2705 * resources.
2707 cfg_queues(adapter);
2710 * Print a short notice on the existence and configuration of the new
2711 * VF network device ...
2713 for_each_port(adapter, pidx) {
2714 dev_info(adapter->pdev_dev, "%s: Chelsio VF NIC PCIe %s\n",
2715 adapter->port[pidx]->name,
2716 (adapter->flags & USING_MSIX) ? "MSI-X" :
2717 (adapter->flags & USING_MSI) ? "MSI" : "");
2721 * Return success!
2723 return 0;
2726 * Error recovery and exit code. Unwind state that's been created
2727 * so far and return the error.
2730 err_free_debugfs:
2731 if (!IS_ERR_OR_NULL(adapter->debugfs_root)) {
2732 cleanup_debugfs(adapter);
2733 debugfs_remove_recursive(adapter->debugfs_root);
2736 err_free_dev:
2737 for_each_port(adapter, pidx) {
2738 netdev = adapter->port[pidx];
2739 if (netdev == NULL)
2740 continue;
2741 pi = netdev_priv(netdev);
2742 t4vf_free_vi(adapter, pi->viid);
2743 if (test_bit(pidx, &adapter->registered_device_map))
2744 unregister_netdev(netdev);
2745 free_netdev(netdev);
2748 err_unmap_bar:
2749 iounmap(adapter->regs);
2751 err_free_adapter:
2752 kfree(adapter);
2753 pci_set_drvdata(pdev, NULL);
2755 err_release_regions:
2756 pci_release_regions(pdev);
2757 pci_set_drvdata(pdev, NULL);
2758 pci_clear_master(pdev);
2760 err_disable_device:
2761 pci_disable_device(pdev);
2763 return err;
2767 * "Remove" a device: tear down all kernel and driver state created in the
2768 * "probe" routine and quiesce the device (disable interrupts, etc.). (Note
2769 * that this is called "remove_one" in the PF Driver.)
2771 static void __devexit cxgb4vf_pci_remove(struct pci_dev *pdev)
2773 struct adapter *adapter = pci_get_drvdata(pdev);
2776 * Tear down driver state associated with device.
2778 if (adapter) {
2779 int pidx;
2782 * Stop all of our activity. Unregister network port,
2783 * disable interrupts, etc.
2785 for_each_port(adapter, pidx)
2786 if (test_bit(pidx, &adapter->registered_device_map))
2787 unregister_netdev(adapter->port[pidx]);
2788 t4vf_sge_stop(adapter);
2789 if (adapter->flags & USING_MSIX) {
2790 pci_disable_msix(adapter->pdev);
2791 adapter->flags &= ~USING_MSIX;
2792 } else if (adapter->flags & USING_MSI) {
2793 pci_disable_msi(adapter->pdev);
2794 adapter->flags &= ~USING_MSI;
2798 * Tear down our debugfs entries.
2800 if (!IS_ERR_OR_NULL(adapter->debugfs_root)) {
2801 cleanup_debugfs(adapter);
2802 debugfs_remove_recursive(adapter->debugfs_root);
2806 * Free all of the various resources which we've acquired ...
2808 t4vf_free_sge_resources(adapter);
2809 for_each_port(adapter, pidx) {
2810 struct net_device *netdev = adapter->port[pidx];
2811 struct port_info *pi;
2813 if (netdev == NULL)
2814 continue;
2816 pi = netdev_priv(netdev);
2817 t4vf_free_vi(adapter, pi->viid);
2818 free_netdev(netdev);
2820 iounmap(adapter->regs);
2821 kfree(adapter);
2822 pci_set_drvdata(pdev, NULL);
2826 * Disable the device and release its PCI resources.
2828 pci_disable_device(pdev);
2829 pci_clear_master(pdev);
2830 pci_release_regions(pdev);
2834 * "Shutdown" quiesce the device, stopping Ingress Packet and Interrupt
2835 * delivery.
2837 static void __devexit cxgb4vf_pci_shutdown(struct pci_dev *pdev)
2839 struct adapter *adapter;
2840 int pidx;
2842 adapter = pci_get_drvdata(pdev);
2843 if (!adapter)
2844 return;
2847 * Disable all Virtual Interfaces. This will shut down the
2848 * delivery of all ingress packets into the chip for these
2849 * Virtual Interfaces.
2851 for_each_port(adapter, pidx) {
2852 struct net_device *netdev;
2853 struct port_info *pi;
2855 if (!test_bit(pidx, &adapter->registered_device_map))
2856 continue;
2858 netdev = adapter->port[pidx];
2859 if (!netdev)
2860 continue;
2862 pi = netdev_priv(netdev);
2863 t4vf_enable_vi(adapter, pi->viid, false, false);
2867 * Free up all Queues which will prevent further DMA and
2868 * Interrupts allowing various internal pathways to drain.
2870 t4vf_free_sge_resources(adapter);
2874 * PCI Device registration data structures.
2876 #define CH_DEVICE(devid, idx) \
2877 { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
2879 static struct pci_device_id cxgb4vf_pci_tbl[] = {
2880 CH_DEVICE(0xb000, 0), /* PE10K FPGA */
2881 CH_DEVICE(0x4800, 0), /* T440-dbg */
2882 CH_DEVICE(0x4801, 0), /* T420-cr */
2883 CH_DEVICE(0x4802, 0), /* T422-cr */
2884 CH_DEVICE(0x4803, 0), /* T440-cr */
2885 CH_DEVICE(0x4804, 0), /* T420-bch */
2886 CH_DEVICE(0x4805, 0), /* T440-bch */
2887 CH_DEVICE(0x4806, 0), /* T460-ch */
2888 CH_DEVICE(0x4807, 0), /* T420-so */
2889 CH_DEVICE(0x4808, 0), /* T420-cx */
2890 CH_DEVICE(0x4809, 0), /* T420-bt */
2891 CH_DEVICE(0x480a, 0), /* T404-bt */
2892 { 0, }
2895 MODULE_DESCRIPTION(DRV_DESC);
2896 MODULE_AUTHOR("Chelsio Communications");
2897 MODULE_LICENSE("Dual BSD/GPL");
2898 MODULE_VERSION(DRV_VERSION);
2899 MODULE_DEVICE_TABLE(pci, cxgb4vf_pci_tbl);
2901 static struct pci_driver cxgb4vf_driver = {
2902 .name = KBUILD_MODNAME,
2903 .id_table = cxgb4vf_pci_tbl,
2904 .probe = cxgb4vf_pci_probe,
2905 .remove = __devexit_p(cxgb4vf_pci_remove),
2906 .shutdown = __devexit_p(cxgb4vf_pci_shutdown),
2910 * Initialize global driver state.
2912 static int __init cxgb4vf_module_init(void)
2914 int ret;
2917 * Vet our module parameters.
2919 if (msi != MSI_MSIX && msi != MSI_MSI) {
2920 printk(KERN_WARNING KBUILD_MODNAME
2921 ": bad module parameter msi=%d; must be %d"
2922 " (MSI-X or MSI) or %d (MSI)\n",
2923 msi, MSI_MSIX, MSI_MSI);
2924 return -EINVAL;
2927 /* Debugfs support is optional, just warn if this fails */
2928 cxgb4vf_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
2929 if (IS_ERR_OR_NULL(cxgb4vf_debugfs_root))
2930 printk(KERN_WARNING KBUILD_MODNAME ": could not create"
2931 " debugfs entry, continuing\n");
2933 ret = pci_register_driver(&cxgb4vf_driver);
2934 if (ret < 0 && !IS_ERR_OR_NULL(cxgb4vf_debugfs_root))
2935 debugfs_remove(cxgb4vf_debugfs_root);
2936 return ret;
2940 * Tear down global driver state.
2942 static void __exit cxgb4vf_module_exit(void)
2944 pci_unregister_driver(&cxgb4vf_driver);
2945 debugfs_remove(cxgb4vf_debugfs_root);
2948 module_init(cxgb4vf_module_init);
2949 module_exit(cxgb4vf_module_exit);