2 * This file is part of the Chelsio T4 PCI-E SR-IOV Virtual Function Ethernet
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
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
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
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"
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).
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 * ======================
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,
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
))
154 * Tell the OS that the link status has changed and print a short
155 * informative message on the console about the event.
160 const struct port_info
*pi
= netdev_priv(dev
);
162 netif_carrier_on(dev
);
164 switch (pi
->link_cfg
.speed
) {
182 switch (pi
->link_cfg
.fc
) {
191 case PAUSE_RX
|PAUSE_TX
:
200 printk(KERN_INFO
"%s: link up, %s, full-duplex, %s PAUSE\n",
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
);
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
230 static int link_start(struct net_device
*dev
)
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,
242 ret
= t4vf_change_mac(pi
->adapter
, pi
->viid
,
243 pi
->xact_addr_filt
, dev
->dev_addr
, true);
245 pi
->xact_addr_filt
= ret
;
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.
256 ret
= t4vf_enable_vi(pi
->adapter
, pi
->viid
, true, true);
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;
271 snprintf(adapter
->msix_info
[MSIX_FW
].desc
, namelen
,
272 "%s-FWeventq", adapter
->name
);
273 adapter
->msix_info
[MSIX_FW
].desc
[namelen
] = 0;
278 for_each_port(adapter
, pidx
) {
279 struct net_device
*dev
= adapter
->port
[pidx
];
280 const struct port_info
*pi
= netdev_priv(dev
);
283 for (qs
= 0, msi
= MSIX_NIQFLINT
;
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
;
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
);
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
);
326 free_irq(adapter
->msix_info
[--msi
].vec
, &s
->ethrxq
[rxq
].rspq
);
327 free_irq(adapter
->msix_info
[MSIX_FW
].vec
, &s
->fw_evtq
);
332 * Free our MSI-X resources.
334 static void free_msix_queue_irqs(struct adapter
*adapter
)
336 struct sge
*s
= &adapter
->sge
;
339 free_irq(adapter
->msix_info
[MSIX_FW
].vec
, &s
->fw_evtq
);
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
357 t4_write_reg(rspq
->adapter
, T4VF_SGE_BASE_ADDR
+ SGE_VF_GTS
,
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
)
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
,
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
;
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);
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
);
424 case CPL_SGE_EGR_UPDATE
: {
426 * We've received an Egress Queue status update message.
427 * We get these, as the SGE is currently configured, when
428 * the firmware passes certain points in processing our
429 * TX Ethernet Queue. We use these updates to determine
430 * when we may need to restart a TX Ethernet Queue which
431 * was stopped for lack of free slots ...
433 const struct cpl_sge_egr_update
*p
= (void *)cpl
;
434 unsigned int qid
= EGR_QID(be32_to_cpu(p
->opcode_qid
));
435 struct sge
*s
= &adapter
->sge
;
437 struct sge_eth_txq
*txq
;
439 int hw_cidx
, reclaimable
, in_use
;
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
);
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
);
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",
469 * Skip TX Queues which aren't stopped.
471 if (likely(!netif_tx_queue_stopped(txq
->txq
)))
475 * Skip stopped TX Queues which have more than half of their
476 * DMA rings occupied with unacknowledged writes.
478 hw_cidx
= be16_to_cpu(txq
->q
.stat
->cidx
);
479 reclaimable
= hw_cidx
- txq
->q
.cidx
;
481 reclaimable
+= txq
->q
.size
;
482 in_use
= txq
->q
.in_use
- reclaimable
;
483 if (in_use
>= txq
->q
.size
/2)
487 * Restart a stopped TX Queue which has less than half of its
491 netif_tx_wake_queue(txq
->txq
);
496 dev_err(adapter
->pdev_dev
,
497 "unexpected CPL %#x on FW event queue\n", opcode
);
504 * Allocate SGE TX/RX response queues. Determine how many sets of SGE queues
505 * to use and initializes them. We support multiple "Queue Sets" per port if
506 * we have MSI-X, otherwise just one queue set per port.
508 static int setup_sge_queues(struct adapter
*adapter
)
510 struct sge
*s
= &adapter
->sge
;
514 * Clear "Queue Set" Free List Starving and TX Queue Mapping Error
517 bitmap_zero(s
->starving_fl
, MAX_EGRQ
);
520 * If we're using MSI interrupt mode we need to set up a "forwarded
521 * interrupt" queue which we'll set up with our MSI vector. The rest
522 * of the ingress queues will be set up to forward their interrupts to
523 * this queue ... This must be first since t4vf_sge_alloc_rxq() uses
524 * the intrq's queue ID as the interrupt forwarding queue for the
525 * subsequent calls ...
527 if (adapter
->flags
& USING_MSI
) {
528 err
= t4vf_sge_alloc_rxq(adapter
, &s
->intrq
, false,
529 adapter
->port
[0], 0, NULL
, NULL
);
531 goto err_free_queues
;
535 * Allocate our ingress queue for asynchronous firmware messages.
537 err
= t4vf_sge_alloc_rxq(adapter
, &s
->fw_evtq
, true, adapter
->port
[0],
538 MSIX_FW
, NULL
, fwevtq_handler
);
540 goto err_free_queues
;
543 * Allocate each "port"'s initial Queue Sets. These can be changed
544 * later on ... up to the point where any interface on the adapter is
545 * brought up at which point lots of things get nailed down
548 msix
= MSIX_NIQFLINT
;
549 for_each_port(adapter
, pidx
) {
550 struct net_device
*dev
= adapter
->port
[pidx
];
551 struct port_info
*pi
= netdev_priv(dev
);
552 struct sge_eth_rxq
*rxq
= &s
->ethrxq
[pi
->first_qset
];
553 struct sge_eth_txq
*txq
= &s
->ethtxq
[pi
->first_qset
];
554 int nqsets
= (adapter
->flags
& USING_MSIX
) ? pi
->nqsets
: 1;
557 for (qs
= 0; qs
< nqsets
; qs
++, rxq
++, txq
++) {
558 err
= t4vf_sge_alloc_rxq(adapter
, &rxq
->rspq
, false,
560 &rxq
->fl
, t4vf_ethrx_handler
);
562 goto err_free_queues
;
564 err
= t4vf_sge_alloc_eth_txq(adapter
, txq
, dev
,
565 netdev_get_tx_queue(dev
, qs
),
566 s
->fw_evtq
.cntxt_id
);
568 goto err_free_queues
;
571 memset(&rxq
->stats
, 0, sizeof(rxq
->stats
));
576 * Create the reverse mappings for the queues.
578 s
->egr_base
= s
->ethtxq
[0].q
.abs_id
- s
->ethtxq
[0].q
.cntxt_id
;
579 s
->ingr_base
= s
->ethrxq
[0].rspq
.abs_id
- s
->ethrxq
[0].rspq
.cntxt_id
;
580 IQ_MAP(s
, s
->fw_evtq
.abs_id
) = &s
->fw_evtq
;
581 for_each_port(adapter
, pidx
) {
582 struct net_device
*dev
= adapter
->port
[pidx
];
583 struct port_info
*pi
= netdev_priv(dev
);
584 struct sge_eth_rxq
*rxq
= &s
->ethrxq
[pi
->first_qset
];
585 struct sge_eth_txq
*txq
= &s
->ethtxq
[pi
->first_qset
];
586 int nqsets
= (adapter
->flags
& USING_MSIX
) ? pi
->nqsets
: 1;
589 for (qs
= 0; qs
< nqsets
; qs
++, rxq
++, txq
++) {
590 IQ_MAP(s
, rxq
->rspq
.abs_id
) = &rxq
->rspq
;
591 EQ_MAP(s
, txq
->q
.abs_id
) = &txq
->q
;
594 * The FW_IQ_CMD doesn't return the Absolute Queue IDs
595 * for Free Lists but since all of the Egress Queues
596 * (including Free Lists) have Relative Queue IDs
597 * which are computed as Absolute - Base Queue ID, we
598 * can synthesize the Absolute Queue IDs for the Free
599 * Lists. This is useful for debugging purposes when
600 * we want to dump Queue Contexts via the PF Driver.
602 rxq
->fl
.abs_id
= rxq
->fl
.cntxt_id
+ s
->egr_base
;
603 EQ_MAP(s
, rxq
->fl
.abs_id
) = &rxq
->fl
;
609 t4vf_free_sge_resources(adapter
);
614 * Set up Receive Side Scaling (RSS) to distribute packets to multiple receive
615 * queues. We configure the RSS CPU lookup table to distribute to the number
616 * of HW receive queues, and the response queue lookup table to narrow that
617 * down to the response queues actually configured for each "port" (Virtual
618 * Interface). We always configure the RSS mapping for all ports since the
619 * mapping table has plenty of entries.
621 static int setup_rss(struct adapter
*adapter
)
625 for_each_port(adapter
, pidx
) {
626 struct port_info
*pi
= adap2pinfo(adapter
, pidx
);
627 struct sge_eth_rxq
*rxq
= &adapter
->sge
.ethrxq
[pi
->first_qset
];
628 u16 rss
[MAX_PORT_QSETS
];
631 for (qs
= 0; qs
< pi
->nqsets
; qs
++)
632 rss
[qs
] = rxq
[qs
].rspq
.abs_id
;
634 err
= t4vf_config_rss_range(adapter
, pi
->viid
,
635 0, pi
->rss_size
, rss
, pi
->nqsets
);
640 * Perform Global RSS Mode-specific initialization.
642 switch (adapter
->params
.rss
.mode
) {
643 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL
:
645 * If Tunnel All Lookup isn't specified in the global
646 * RSS Configuration, then we need to specify a
647 * default Ingress Queue for any ingress packets which
648 * aren't hashed. We'll use our first ingress queue
651 if (!adapter
->params
.rss
.u
.basicvirtual
.tnlalllookup
) {
652 union rss_vi_config config
;
653 err
= t4vf_read_rss_vi_config(adapter
,
658 config
.basicvirtual
.defaultq
=
660 err
= t4vf_write_rss_vi_config(adapter
,
674 * Bring the adapter up. Called whenever we go from no "ports" open to having
675 * one open. This function performs the actions necessary to make an adapter
676 * operational, such as completing the initialization of HW modules, and
677 * enabling interrupts. Must be called with the rtnl lock held. (Note that
678 * this is called "cxgb_up" in the PF Driver.)
680 static int adapter_up(struct adapter
*adapter
)
685 * If this is the first time we've been called, perform basic
686 * adapter setup. Once we've done this, many of our adapter
687 * parameters can no longer be changed ...
689 if ((adapter
->flags
& FULL_INIT_DONE
) == 0) {
690 err
= setup_sge_queues(adapter
);
693 err
= setup_rss(adapter
);
695 t4vf_free_sge_resources(adapter
);
699 if (adapter
->flags
& USING_MSIX
)
700 name_msix_vecs(adapter
);
701 adapter
->flags
|= FULL_INIT_DONE
;
705 * Acquire our interrupt resources. We only support MSI-X and MSI.
707 BUG_ON((adapter
->flags
& (USING_MSIX
|USING_MSI
)) == 0);
708 if (adapter
->flags
& USING_MSIX
)
709 err
= request_msix_queue_irqs(adapter
);
711 err
= request_irq(adapter
->pdev
->irq
,
712 t4vf_intr_handler(adapter
), 0,
713 adapter
->name
, adapter
);
715 dev_err(adapter
->pdev_dev
, "request_irq failed, err %d\n",
721 * Enable NAPI ingress processing and return success.
724 t4vf_sge_start(adapter
);
729 * Bring the adapter down. Called whenever the last "port" (Virtual
730 * Interface) closed. (Note that this routine is called "cxgb_down" in the PF
733 static void adapter_down(struct adapter
*adapter
)
736 * Free interrupt resources.
738 if (adapter
->flags
& USING_MSIX
)
739 free_msix_queue_irqs(adapter
);
741 free_irq(adapter
->pdev
->irq
, adapter
);
744 * Wait for NAPI handlers to finish.
750 * Start up a net device.
752 static int cxgb4vf_open(struct net_device
*dev
)
755 struct port_info
*pi
= netdev_priv(dev
);
756 struct adapter
*adapter
= pi
->adapter
;
759 * If this is the first interface that we're opening on the "adapter",
760 * bring the "adapter" up now.
762 if (adapter
->open_device_map
== 0) {
763 err
= adapter_up(adapter
);
769 * Note that this interface is up and start everything up ...
771 dev
->real_num_tx_queues
= pi
->nqsets
;
772 set_bit(pi
->port_id
, &adapter
->open_device_map
);
774 netif_tx_start_all_queues(dev
);
779 * Shut down a net device. This routine is called "cxgb_close" in the PF
782 static int cxgb4vf_stop(struct net_device
*dev
)
785 struct port_info
*pi
= netdev_priv(dev
);
786 struct adapter
*adapter
= pi
->adapter
;
788 netif_tx_stop_all_queues(dev
);
789 netif_carrier_off(dev
);
790 ret
= t4vf_enable_vi(adapter
, pi
->viid
, false, false);
791 pi
->link_cfg
.link_ok
= 0;
793 clear_bit(pi
->port_id
, &adapter
->open_device_map
);
794 if (adapter
->open_device_map
== 0)
795 adapter_down(adapter
);
800 * Translate our basic statistics into the standard "ifconfig" statistics.
802 static struct net_device_stats
*cxgb4vf_get_stats(struct net_device
*dev
)
804 struct t4vf_port_stats stats
;
805 struct port_info
*pi
= netdev2pinfo(dev
);
806 struct adapter
*adapter
= pi
->adapter
;
807 struct net_device_stats
*ns
= &dev
->stats
;
810 spin_lock(&adapter
->stats_lock
);
811 err
= t4vf_get_port_stats(adapter
, pi
->pidx
, &stats
);
812 spin_unlock(&adapter
->stats_lock
);
814 memset(ns
, 0, sizeof(*ns
));
818 ns
->tx_bytes
= (stats
.tx_bcast_bytes
+ stats
.tx_mcast_bytes
+
819 stats
.tx_ucast_bytes
+ stats
.tx_offload_bytes
);
820 ns
->tx_packets
= (stats
.tx_bcast_frames
+ stats
.tx_mcast_frames
+
821 stats
.tx_ucast_frames
+ stats
.tx_offload_frames
);
822 ns
->rx_bytes
= (stats
.rx_bcast_bytes
+ stats
.rx_mcast_bytes
+
823 stats
.rx_ucast_bytes
);
824 ns
->rx_packets
= (stats
.rx_bcast_frames
+ stats
.rx_mcast_frames
+
825 stats
.rx_ucast_frames
);
826 ns
->multicast
= stats
.rx_mcast_frames
;
827 ns
->tx_errors
= stats
.tx_drop_frames
;
828 ns
->rx_errors
= stats
.rx_err_frames
;
834 * Collect up to maxaddrs worth of a netdevice's unicast addresses into an
835 * array of addrss pointers and return the number collected.
837 static inline int collect_netdev_uc_list_addrs(const struct net_device
*dev
,
839 unsigned int maxaddrs
)
841 unsigned int naddr
= 0;
842 const struct netdev_hw_addr
*ha
;
844 for_each_dev_addr(dev
, ha
) {
845 addr
[naddr
++] = ha
->addr
;
846 if (naddr
>= maxaddrs
)
853 * Collect up to maxaddrs worth of a netdevice's multicast addresses into an
854 * array of addrss pointers and return the number collected.
856 static inline int collect_netdev_mc_list_addrs(const struct net_device
*dev
,
858 unsigned int maxaddrs
)
860 unsigned int naddr
= 0;
861 const struct netdev_hw_addr
*ha
;
863 netdev_for_each_mc_addr(ha
, dev
) {
864 addr
[naddr
++] = ha
->addr
;
865 if (naddr
>= maxaddrs
)
872 * Configure the exact and hash address filters to handle a port's multicast
873 * and secondary unicast MAC addresses.
875 static int set_addr_filters(const struct net_device
*dev
, bool sleep
)
883 const struct port_info
*pi
= netdev_priv(dev
);
885 /* first do the secondary unicast addresses */
886 naddr
= collect_netdev_uc_list_addrs(dev
, addr
, ARRAY_SIZE(addr
));
888 ret
= t4vf_alloc_mac_filt(pi
->adapter
, pi
->viid
, free
,
889 naddr
, addr
, filt_idx
, &uhash
, sleep
);
896 /* next set up the multicast addresses */
897 naddr
= collect_netdev_mc_list_addrs(dev
, addr
, ARRAY_SIZE(addr
));
899 ret
= t4vf_alloc_mac_filt(pi
->adapter
, pi
->viid
, free
,
900 naddr
, addr
, filt_idx
, &mhash
, sleep
);
905 return t4vf_set_addr_hash(pi
->adapter
, pi
->viid
, uhash
!= 0,
906 uhash
| mhash
, sleep
);
910 * Set RX properties of a port, such as promiscruity, address filters, and MTU.
911 * If @mtu is -1 it is left unchanged.
913 static int set_rxmode(struct net_device
*dev
, int mtu
, bool sleep_ok
)
916 struct port_info
*pi
= netdev_priv(dev
);
918 ret
= set_addr_filters(dev
, sleep_ok
);
920 ret
= t4vf_set_rxmode(pi
->adapter
, pi
->viid
, -1,
921 (dev
->flags
& IFF_PROMISC
) != 0,
922 (dev
->flags
& IFF_ALLMULTI
) != 0,
928 * Set the current receive modes on the device.
930 static void cxgb4vf_set_rxmode(struct net_device
*dev
)
932 /* unfortunately we can't return errors to the stack */
933 set_rxmode(dev
, -1, false);
937 * Find the entry in the interrupt holdoff timer value array which comes
938 * closest to the specified interrupt holdoff value.
940 static int closest_timer(const struct sge
*s
, int us
)
942 int i
, timer_idx
= 0, min_delta
= INT_MAX
;
944 for (i
= 0; i
< ARRAY_SIZE(s
->timer_val
); i
++) {
945 int delta
= us
- s
->timer_val
[i
];
948 if (delta
< min_delta
) {
956 static int closest_thres(const struct sge
*s
, int thres
)
958 int i
, delta
, pktcnt_idx
= 0, min_delta
= INT_MAX
;
960 for (i
= 0; i
< ARRAY_SIZE(s
->counter_val
); i
++) {
961 delta
= thres
- s
->counter_val
[i
];
964 if (delta
< min_delta
) {
973 * Return a queue's interrupt hold-off time in us. 0 means no timer.
975 static unsigned int qtimer_val(const struct adapter
*adapter
,
976 const struct sge_rspq
*rspq
)
978 unsigned int timer_idx
= QINTR_TIMER_IDX_GET(rspq
->intr_params
);
980 return timer_idx
< SGE_NTIMERS
981 ? adapter
->sge
.timer_val
[timer_idx
]
986 * set_rxq_intr_params - set a queue's interrupt holdoff parameters
987 * @adapter: the adapter
988 * @rspq: the RX response queue
989 * @us: the hold-off time in us, or 0 to disable timer
990 * @cnt: the hold-off packet count, or 0 to disable counter
992 * Sets an RX response queue's interrupt hold-off time and packet count.
993 * At least one of the two needs to be enabled for the queue to generate
996 static int set_rxq_intr_params(struct adapter
*adapter
, struct sge_rspq
*rspq
,
997 unsigned int us
, unsigned int cnt
)
999 unsigned int timer_idx
;
1002 * If both the interrupt holdoff timer and count are specified as
1003 * zero, default to a holdoff count of 1 ...
1005 if ((us
| cnt
) == 0)
1009 * If an interrupt holdoff count has been specified, then find the
1010 * closest configured holdoff count and use that. If the response
1011 * queue has already been created, then update its queue context
1018 pktcnt_idx
= closest_thres(&adapter
->sge
, cnt
);
1019 if (rspq
->desc
&& rspq
->pktcnt_idx
!= pktcnt_idx
) {
1020 v
= FW_PARAMS_MNEM(FW_PARAMS_MNEM_DMAQ
) |
1022 FW_PARAMS_PARAM_DMAQ_IQ_INTCNTTHRESH
) |
1023 FW_PARAMS_PARAM_YZ(rspq
->cntxt_id
);
1024 err
= t4vf_set_params(adapter
, 1, &v
, &pktcnt_idx
);
1028 rspq
->pktcnt_idx
= pktcnt_idx
;
1032 * Compute the closest holdoff timer index from the supplied holdoff
1035 timer_idx
= (us
== 0
1036 ? SGE_TIMER_RSTRT_CNTR
1037 : closest_timer(&adapter
->sge
, us
));
1040 * Update the response queue's interrupt coalescing parameters and
1043 rspq
->intr_params
= (QINTR_TIMER_IDX(timer_idx
) |
1044 (cnt
> 0 ? QINTR_CNT_EN
: 0));
1049 * Return a version number to identify the type of adapter. The scheme is:
1050 * - bits 0..9: chip version
1051 * - bits 10..15: chip revision
1053 static inline unsigned int mk_adap_vers(const struct adapter
*adapter
)
1056 * Chip version 4, revision 0x3f (cxgb4vf).
1058 return 4 | (0x3f << 10);
1062 * Execute the specified ioctl command.
1064 static int cxgb4vf_do_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1070 * The VF Driver doesn't have access to any of the other
1071 * common Ethernet device ioctl()'s (like reading/writing
1072 * PHY registers, etc.
1083 * Change the device's MTU.
1085 static int cxgb4vf_change_mtu(struct net_device
*dev
, int new_mtu
)
1088 struct port_info
*pi
= netdev_priv(dev
);
1090 /* accommodate SACK */
1094 ret
= t4vf_set_rxmode(pi
->adapter
, pi
->viid
, new_mtu
,
1095 -1, -1, -1, -1, true);
1102 * Change the devices MAC address.
1104 static int cxgb4vf_set_mac_addr(struct net_device
*dev
, void *_addr
)
1107 struct sockaddr
*addr
= _addr
;
1108 struct port_info
*pi
= netdev_priv(dev
);
1110 if (!is_valid_ether_addr(addr
->sa_data
))
1113 ret
= t4vf_change_mac(pi
->adapter
, pi
->viid
, pi
->xact_addr_filt
,
1114 addr
->sa_data
, true);
1118 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1119 pi
->xact_addr_filt
= ret
;
1124 * Return a TX Queue on which to send the specified skb.
1126 static u16
cxgb4vf_select_queue(struct net_device
*dev
, struct sk_buff
*skb
)
1129 * XXX For now just use the default hash but we probably want to
1130 * XXX look at other possibilities ...
1132 return skb_tx_hash(dev
, skb
);
1135 #ifdef CONFIG_NET_POLL_CONTROLLER
1137 * Poll all of our receive queues. This is called outside of normal interrupt
1140 static void cxgb4vf_poll_controller(struct net_device
*dev
)
1142 struct port_info
*pi
= netdev_priv(dev
);
1143 struct adapter
*adapter
= pi
->adapter
;
1145 if (adapter
->flags
& USING_MSIX
) {
1146 struct sge_eth_rxq
*rxq
;
1149 rxq
= &adapter
->sge
.ethrxq
[pi
->first_qset
];
1150 for (nqsets
= pi
->nqsets
; nqsets
; nqsets
--) {
1151 t4vf_sge_intr_msix(0, &rxq
->rspq
);
1155 t4vf_intr_handler(adapter
)(0, adapter
);
1160 * Ethtool operations.
1161 * ===================
1163 * Note that we don't support any ethtool operations which change the physical
1164 * state of the port to which we're linked.
1168 * Return current port link settings.
1170 static int cxgb4vf_get_settings(struct net_device
*dev
,
1171 struct ethtool_cmd
*cmd
)
1173 const struct port_info
*pi
= netdev_priv(dev
);
1175 cmd
->supported
= pi
->link_cfg
.supported
;
1176 cmd
->advertising
= pi
->link_cfg
.advertising
;
1177 cmd
->speed
= netif_carrier_ok(dev
) ? pi
->link_cfg
.speed
: -1;
1178 cmd
->duplex
= DUPLEX_FULL
;
1180 cmd
->port
= (cmd
->supported
& SUPPORTED_TP
) ? PORT_TP
: PORT_FIBRE
;
1181 cmd
->phy_address
= pi
->port_id
;
1182 cmd
->transceiver
= XCVR_EXTERNAL
;
1183 cmd
->autoneg
= pi
->link_cfg
.autoneg
;
1190 * Return our driver information.
1192 static void cxgb4vf_get_drvinfo(struct net_device
*dev
,
1193 struct ethtool_drvinfo
*drvinfo
)
1195 struct adapter
*adapter
= netdev2adap(dev
);
1197 strcpy(drvinfo
->driver
, KBUILD_MODNAME
);
1198 strcpy(drvinfo
->version
, DRV_VERSION
);
1199 strcpy(drvinfo
->bus_info
, pci_name(to_pci_dev(dev
->dev
.parent
)));
1200 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
),
1201 "%u.%u.%u.%u, TP %u.%u.%u.%u",
1202 FW_HDR_FW_VER_MAJOR_GET(adapter
->params
.dev
.fwrev
),
1203 FW_HDR_FW_VER_MINOR_GET(adapter
->params
.dev
.fwrev
),
1204 FW_HDR_FW_VER_MICRO_GET(adapter
->params
.dev
.fwrev
),
1205 FW_HDR_FW_VER_BUILD_GET(adapter
->params
.dev
.fwrev
),
1206 FW_HDR_FW_VER_MAJOR_GET(adapter
->params
.dev
.tprev
),
1207 FW_HDR_FW_VER_MINOR_GET(adapter
->params
.dev
.tprev
),
1208 FW_HDR_FW_VER_MICRO_GET(adapter
->params
.dev
.tprev
),
1209 FW_HDR_FW_VER_BUILD_GET(adapter
->params
.dev
.tprev
));
1213 * Return current adapter message level.
1215 static u32
cxgb4vf_get_msglevel(struct net_device
*dev
)
1217 return netdev2adap(dev
)->msg_enable
;
1221 * Set current adapter message level.
1223 static void cxgb4vf_set_msglevel(struct net_device
*dev
, u32 msglevel
)
1225 netdev2adap(dev
)->msg_enable
= msglevel
;
1229 * Return the device's current Queue Set ring size parameters along with the
1230 * allowed maximum values. Since ethtool doesn't understand the concept of
1231 * multi-queue devices, we just return the current values associated with the
1234 static void cxgb4vf_get_ringparam(struct net_device
*dev
,
1235 struct ethtool_ringparam
*rp
)
1237 const struct port_info
*pi
= netdev_priv(dev
);
1238 const struct sge
*s
= &pi
->adapter
->sge
;
1240 rp
->rx_max_pending
= MAX_RX_BUFFERS
;
1241 rp
->rx_mini_max_pending
= MAX_RSPQ_ENTRIES
;
1242 rp
->rx_jumbo_max_pending
= 0;
1243 rp
->tx_max_pending
= MAX_TXQ_ENTRIES
;
1245 rp
->rx_pending
= s
->ethrxq
[pi
->first_qset
].fl
.size
- MIN_FL_RESID
;
1246 rp
->rx_mini_pending
= s
->ethrxq
[pi
->first_qset
].rspq
.size
;
1247 rp
->rx_jumbo_pending
= 0;
1248 rp
->tx_pending
= s
->ethtxq
[pi
->first_qset
].q
.size
;
1252 * Set the Queue Set ring size parameters for the device. Again, since
1253 * ethtool doesn't allow for the concept of multiple queues per device, we'll
1254 * apply these new values across all of the Queue Sets associated with the
1255 * device -- after vetting them of course!
1257 static int cxgb4vf_set_ringparam(struct net_device
*dev
,
1258 struct ethtool_ringparam
*rp
)
1260 const struct port_info
*pi
= netdev_priv(dev
);
1261 struct adapter
*adapter
= pi
->adapter
;
1262 struct sge
*s
= &adapter
->sge
;
1265 if (rp
->rx_pending
> MAX_RX_BUFFERS
||
1266 rp
->rx_jumbo_pending
||
1267 rp
->tx_pending
> MAX_TXQ_ENTRIES
||
1268 rp
->rx_mini_pending
> MAX_RSPQ_ENTRIES
||
1269 rp
->rx_mini_pending
< MIN_RSPQ_ENTRIES
||
1270 rp
->rx_pending
< MIN_FL_ENTRIES
||
1271 rp
->tx_pending
< MIN_TXQ_ENTRIES
)
1274 if (adapter
->flags
& FULL_INIT_DONE
)
1277 for (qs
= pi
->first_qset
; qs
< pi
->first_qset
+ pi
->nqsets
; qs
++) {
1278 s
->ethrxq
[qs
].fl
.size
= rp
->rx_pending
+ MIN_FL_RESID
;
1279 s
->ethrxq
[qs
].rspq
.size
= rp
->rx_mini_pending
;
1280 s
->ethtxq
[qs
].q
.size
= rp
->tx_pending
;
1286 * Return the interrupt holdoff timer and count for the first Queue Set on the
1287 * device. Our extension ioctl() (the cxgbtool interface) allows the
1288 * interrupt holdoff timer to be read on all of the device's Queue Sets.
1290 static int cxgb4vf_get_coalesce(struct net_device
*dev
,
1291 struct ethtool_coalesce
*coalesce
)
1293 const struct port_info
*pi
= netdev_priv(dev
);
1294 const struct adapter
*adapter
= pi
->adapter
;
1295 const struct sge_rspq
*rspq
= &adapter
->sge
.ethrxq
[pi
->first_qset
].rspq
;
1297 coalesce
->rx_coalesce_usecs
= qtimer_val(adapter
, rspq
);
1298 coalesce
->rx_max_coalesced_frames
=
1299 ((rspq
->intr_params
& QINTR_CNT_EN
)
1300 ? adapter
->sge
.counter_val
[rspq
->pktcnt_idx
]
1306 * Set the RX interrupt holdoff timer and count for the first Queue Set on the
1307 * interface. Our extension ioctl() (the cxgbtool interface) allows us to set
1308 * the interrupt holdoff timer on any of the device's Queue Sets.
1310 static int cxgb4vf_set_coalesce(struct net_device
*dev
,
1311 struct ethtool_coalesce
*coalesce
)
1313 const struct port_info
*pi
= netdev_priv(dev
);
1314 struct adapter
*adapter
= pi
->adapter
;
1316 return set_rxq_intr_params(adapter
,
1317 &adapter
->sge
.ethrxq
[pi
->first_qset
].rspq
,
1318 coalesce
->rx_coalesce_usecs
,
1319 coalesce
->rx_max_coalesced_frames
);
1323 * Report current port link pause parameter settings.
1325 static void cxgb4vf_get_pauseparam(struct net_device
*dev
,
1326 struct ethtool_pauseparam
*pauseparam
)
1328 struct port_info
*pi
= netdev_priv(dev
);
1330 pauseparam
->autoneg
= (pi
->link_cfg
.requested_fc
& PAUSE_AUTONEG
) != 0;
1331 pauseparam
->rx_pause
= (pi
->link_cfg
.fc
& PAUSE_RX
) != 0;
1332 pauseparam
->tx_pause
= (pi
->link_cfg
.fc
& PAUSE_TX
) != 0;
1336 * Return whether RX Checksum Offloading is currently enabled for the device.
1338 static u32
cxgb4vf_get_rx_csum(struct net_device
*dev
)
1340 struct port_info
*pi
= netdev_priv(dev
);
1342 return (pi
->rx_offload
& RX_CSO
) != 0;
1346 * Turn RX Checksum Offloading on or off for the device.
1348 static int cxgb4vf_set_rx_csum(struct net_device
*dev
, u32 csum
)
1350 struct port_info
*pi
= netdev_priv(dev
);
1353 pi
->rx_offload
|= RX_CSO
;
1355 pi
->rx_offload
&= ~RX_CSO
;
1360 * Identify the port by blinking the port's LED.
1362 static int cxgb4vf_phys_id(struct net_device
*dev
, u32 id
)
1364 struct port_info
*pi
= netdev_priv(dev
);
1366 return t4vf_identify_port(pi
->adapter
, pi
->viid
, 5);
1370 * Port stats maintained per queue of the port.
1372 struct queue_port_stats
{
1381 * Strings for the ETH_SS_STATS statistics set ("ethtool -S"). Note that
1382 * these need to match the order of statistics returned by
1383 * t4vf_get_port_stats().
1385 static const char stats_strings
[][ETH_GSTRING_LEN
] = {
1387 * These must match the layout of the t4vf_port_stats structure.
1389 "TxBroadcastBytes ",
1390 "TxBroadcastFrames ",
1391 "TxMulticastBytes ",
1392 "TxMulticastFrames ",
1398 "RxBroadcastBytes ",
1399 "RxBroadcastFrames ",
1400 "RxMulticastBytes ",
1401 "RxMulticastFrames ",
1407 * These are accumulated per-queue statistics and must match the
1408 * order of the fields in the queue_port_stats structure.
1418 * Return the number of statistics in the specified statistics set.
1420 static int cxgb4vf_get_sset_count(struct net_device
*dev
, int sset
)
1424 return ARRAY_SIZE(stats_strings
);
1432 * Return the strings for the specified statistics set.
1434 static void cxgb4vf_get_strings(struct net_device
*dev
,
1440 memcpy(data
, stats_strings
, sizeof(stats_strings
));
1446 * Small utility routine to accumulate queue statistics across the queues of
1449 static void collect_sge_port_stats(const struct adapter
*adapter
,
1450 const struct port_info
*pi
,
1451 struct queue_port_stats
*stats
)
1453 const struct sge_eth_txq
*txq
= &adapter
->sge
.ethtxq
[pi
->first_qset
];
1454 const struct sge_eth_rxq
*rxq
= &adapter
->sge
.ethrxq
[pi
->first_qset
];
1457 memset(stats
, 0, sizeof(*stats
));
1458 for (qs
= 0; qs
< pi
->nqsets
; qs
++, rxq
++, txq
++) {
1459 stats
->tso
+= txq
->tso
;
1460 stats
->tx_csum
+= txq
->tx_cso
;
1461 stats
->rx_csum
+= rxq
->stats
.rx_cso
;
1462 stats
->vlan_ex
+= rxq
->stats
.vlan_ex
;
1463 stats
->vlan_ins
+= txq
->vlan_ins
;
1468 * Return the ETH_SS_STATS statistics set.
1470 static void cxgb4vf_get_ethtool_stats(struct net_device
*dev
,
1471 struct ethtool_stats
*stats
,
1474 struct port_info
*pi
= netdev2pinfo(dev
);
1475 struct adapter
*adapter
= pi
->adapter
;
1476 int err
= t4vf_get_port_stats(adapter
, pi
->pidx
,
1477 (struct t4vf_port_stats
*)data
);
1479 memset(data
, 0, sizeof(struct t4vf_port_stats
));
1481 data
+= sizeof(struct t4vf_port_stats
) / sizeof(u64
);
1482 collect_sge_port_stats(adapter
, pi
, (struct queue_port_stats
*)data
);
1486 * Return the size of our register map.
1488 static int cxgb4vf_get_regs_len(struct net_device
*dev
)
1490 return T4VF_REGMAP_SIZE
;
1494 * Dump a block of registers, start to end inclusive, into a buffer.
1496 static void reg_block_dump(struct adapter
*adapter
, void *regbuf
,
1497 unsigned int start
, unsigned int end
)
1499 u32
*bp
= regbuf
+ start
- T4VF_REGMAP_START
;
1501 for ( ; start
<= end
; start
+= sizeof(u32
)) {
1503 * Avoid reading the Mailbox Control register since that
1504 * can trigger a Mailbox Ownership Arbitration cycle and
1505 * interfere with communication with the firmware.
1507 if (start
== T4VF_CIM_BASE_ADDR
+ CIM_VF_EXT_MAILBOX_CTRL
)
1510 *bp
++ = t4_read_reg(adapter
, start
);
1515 * Copy our entire register map into the provided buffer.
1517 static void cxgb4vf_get_regs(struct net_device
*dev
,
1518 struct ethtool_regs
*regs
,
1521 struct adapter
*adapter
= netdev2adap(dev
);
1523 regs
->version
= mk_adap_vers(adapter
);
1526 * Fill in register buffer with our register map.
1528 memset(regbuf
, 0, T4VF_REGMAP_SIZE
);
1530 reg_block_dump(adapter
, regbuf
,
1531 T4VF_SGE_BASE_ADDR
+ T4VF_MOD_MAP_SGE_FIRST
,
1532 T4VF_SGE_BASE_ADDR
+ T4VF_MOD_MAP_SGE_LAST
);
1533 reg_block_dump(adapter
, regbuf
,
1534 T4VF_MPS_BASE_ADDR
+ T4VF_MOD_MAP_MPS_FIRST
,
1535 T4VF_MPS_BASE_ADDR
+ T4VF_MOD_MAP_MPS_LAST
);
1536 reg_block_dump(adapter
, regbuf
,
1537 T4VF_PL_BASE_ADDR
+ T4VF_MOD_MAP_PL_FIRST
,
1538 T4VF_PL_BASE_ADDR
+ T4VF_MOD_MAP_PL_LAST
);
1539 reg_block_dump(adapter
, regbuf
,
1540 T4VF_CIM_BASE_ADDR
+ T4VF_MOD_MAP_CIM_FIRST
,
1541 T4VF_CIM_BASE_ADDR
+ T4VF_MOD_MAP_CIM_LAST
);
1543 reg_block_dump(adapter
, regbuf
,
1544 T4VF_MBDATA_BASE_ADDR
+ T4VF_MBDATA_FIRST
,
1545 T4VF_MBDATA_BASE_ADDR
+ T4VF_MBDATA_LAST
);
1549 * Report current Wake On LAN settings.
1551 static void cxgb4vf_get_wol(struct net_device
*dev
,
1552 struct ethtool_wolinfo
*wol
)
1556 memset(&wol
->sopass
, 0, sizeof(wol
->sopass
));
1560 * Set TCP Segmentation Offloading feature capabilities.
1562 static int cxgb4vf_set_tso(struct net_device
*dev
, u32 tso
)
1565 dev
->features
|= NETIF_F_TSO
| NETIF_F_TSO6
;
1567 dev
->features
&= ~(NETIF_F_TSO
| NETIF_F_TSO6
);
1571 static struct ethtool_ops cxgb4vf_ethtool_ops
= {
1572 .get_settings
= cxgb4vf_get_settings
,
1573 .get_drvinfo
= cxgb4vf_get_drvinfo
,
1574 .get_msglevel
= cxgb4vf_get_msglevel
,
1575 .set_msglevel
= cxgb4vf_set_msglevel
,
1576 .get_ringparam
= cxgb4vf_get_ringparam
,
1577 .set_ringparam
= cxgb4vf_set_ringparam
,
1578 .get_coalesce
= cxgb4vf_get_coalesce
,
1579 .set_coalesce
= cxgb4vf_set_coalesce
,
1580 .get_pauseparam
= cxgb4vf_get_pauseparam
,
1581 .get_rx_csum
= cxgb4vf_get_rx_csum
,
1582 .set_rx_csum
= cxgb4vf_set_rx_csum
,
1583 .set_tx_csum
= ethtool_op_set_tx_ipv6_csum
,
1584 .set_sg
= ethtool_op_set_sg
,
1585 .get_link
= ethtool_op_get_link
,
1586 .get_strings
= cxgb4vf_get_strings
,
1587 .phys_id
= cxgb4vf_phys_id
,
1588 .get_sset_count
= cxgb4vf_get_sset_count
,
1589 .get_ethtool_stats
= cxgb4vf_get_ethtool_stats
,
1590 .get_regs_len
= cxgb4vf_get_regs_len
,
1591 .get_regs
= cxgb4vf_get_regs
,
1592 .get_wol
= cxgb4vf_get_wol
,
1593 .set_tso
= cxgb4vf_set_tso
,
1597 * /sys/kernel/debug/cxgb4vf support code and data.
1598 * ================================================
1602 * Show SGE Queue Set information. We display QPL Queues Sets per line.
1606 static int sge_qinfo_show(struct seq_file
*seq
, void *v
)
1608 struct adapter
*adapter
= seq
->private;
1609 int eth_entries
= DIV_ROUND_UP(adapter
->sge
.ethqsets
, QPL
);
1610 int qs
, r
= (uintptr_t)v
- 1;
1613 seq_putc(seq
, '\n');
1615 #define S3(fmt_spec, s, v) \
1617 seq_printf(seq, "%-12s", s); \
1618 for (qs = 0; qs < n; ++qs) \
1619 seq_printf(seq, " %16" fmt_spec, v); \
1620 seq_putc(seq, '\n'); \
1622 #define S(s, v) S3("s", s, v)
1623 #define T(s, v) S3("u", s, txq[qs].v)
1624 #define R(s, v) S3("u", s, rxq[qs].v)
1626 if (r
< eth_entries
) {
1627 const struct sge_eth_rxq
*rxq
= &adapter
->sge
.ethrxq
[r
* QPL
];
1628 const struct sge_eth_txq
*txq
= &adapter
->sge
.ethtxq
[r
* QPL
];
1629 int n
= min(QPL
, adapter
->sge
.ethqsets
- QPL
* r
);
1631 S("QType:", "Ethernet");
1633 (rxq
[qs
].rspq
.netdev
1634 ? rxq
[qs
].rspq
.netdev
->name
1637 (rxq
[qs
].rspq
.netdev
1638 ? ((struct port_info
*)
1639 netdev_priv(rxq
[qs
].rspq
.netdev
))->port_id
1641 T("TxQ ID:", q
.abs_id
);
1642 T("TxQ size:", q
.size
);
1643 T("TxQ inuse:", q
.in_use
);
1644 T("TxQ PIdx:", q
.pidx
);
1645 T("TxQ CIdx:", q
.cidx
);
1646 R("RspQ ID:", rspq
.abs_id
);
1647 R("RspQ size:", rspq
.size
);
1648 R("RspQE size:", rspq
.iqe_len
);
1649 S3("u", "Intr delay:", qtimer_val(adapter
, &rxq
[qs
].rspq
));
1650 S3("u", "Intr pktcnt:",
1651 adapter
->sge
.counter_val
[rxq
[qs
].rspq
.pktcnt_idx
]);
1652 R("RspQ CIdx:", rspq
.cidx
);
1653 R("RspQ Gen:", rspq
.gen
);
1654 R("FL ID:", fl
.abs_id
);
1655 R("FL size:", fl
.size
- MIN_FL_RESID
);
1656 R("FL avail:", fl
.avail
);
1657 R("FL PIdx:", fl
.pidx
);
1658 R("FL CIdx:", fl
.cidx
);
1664 const struct sge_rspq
*evtq
= &adapter
->sge
.fw_evtq
;
1666 seq_printf(seq
, "%-12s %16s\n", "QType:", "FW event queue");
1667 seq_printf(seq
, "%-12s %16u\n", "RspQ ID:", evtq
->abs_id
);
1668 seq_printf(seq
, "%-12s %16u\n", "Intr delay:",
1669 qtimer_val(adapter
, evtq
));
1670 seq_printf(seq
, "%-12s %16u\n", "Intr pktcnt:",
1671 adapter
->sge
.counter_val
[evtq
->pktcnt_idx
]);
1672 seq_printf(seq
, "%-12s %16u\n", "RspQ Cidx:", evtq
->cidx
);
1673 seq_printf(seq
, "%-12s %16u\n", "RspQ Gen:", evtq
->gen
);
1674 } else if (r
== 1) {
1675 const struct sge_rspq
*intrq
= &adapter
->sge
.intrq
;
1677 seq_printf(seq
, "%-12s %16s\n", "QType:", "Interrupt Queue");
1678 seq_printf(seq
, "%-12s %16u\n", "RspQ ID:", intrq
->abs_id
);
1679 seq_printf(seq
, "%-12s %16u\n", "Intr delay:",
1680 qtimer_val(adapter
, intrq
));
1681 seq_printf(seq
, "%-12s %16u\n", "Intr pktcnt:",
1682 adapter
->sge
.counter_val
[intrq
->pktcnt_idx
]);
1683 seq_printf(seq
, "%-12s %16u\n", "RspQ Cidx:", intrq
->cidx
);
1684 seq_printf(seq
, "%-12s %16u\n", "RspQ Gen:", intrq
->gen
);
1696 * Return the number of "entries" in our "file". We group the multi-Queue
1697 * sections with QPL Queue Sets per "entry". The sections of the output are:
1699 * Ethernet RX/TX Queue Sets
1700 * Firmware Event Queue
1701 * Forwarded Interrupt Queue (if in MSI mode)
1703 static int sge_queue_entries(const struct adapter
*adapter
)
1705 return DIV_ROUND_UP(adapter
->sge
.ethqsets
, QPL
) + 1 +
1706 ((adapter
->flags
& USING_MSI
) != 0);
1709 static void *sge_queue_start(struct seq_file
*seq
, loff_t
*pos
)
1711 int entries
= sge_queue_entries(seq
->private);
1713 return *pos
< entries
? (void *)((uintptr_t)*pos
+ 1) : NULL
;
1716 static void sge_queue_stop(struct seq_file
*seq
, void *v
)
1720 static void *sge_queue_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1722 int entries
= sge_queue_entries(seq
->private);
1725 return *pos
< entries
? (void *)((uintptr_t)*pos
+ 1) : NULL
;
1728 static const struct seq_operations sge_qinfo_seq_ops
= {
1729 .start
= sge_queue_start
,
1730 .next
= sge_queue_next
,
1731 .stop
= sge_queue_stop
,
1732 .show
= sge_qinfo_show
1735 static int sge_qinfo_open(struct inode
*inode
, struct file
*file
)
1737 int res
= seq_open(file
, &sge_qinfo_seq_ops
);
1740 struct seq_file
*seq
= file
->private_data
;
1741 seq
->private = inode
->i_private
;
1746 static const struct file_operations sge_qinfo_debugfs_fops
= {
1747 .owner
= THIS_MODULE
,
1748 .open
= sge_qinfo_open
,
1750 .llseek
= seq_lseek
,
1751 .release
= seq_release
,
1755 * Show SGE Queue Set statistics. We display QPL Queues Sets per line.
1759 static int sge_qstats_show(struct seq_file
*seq
, void *v
)
1761 struct adapter
*adapter
= seq
->private;
1762 int eth_entries
= DIV_ROUND_UP(adapter
->sge
.ethqsets
, QPL
);
1763 int qs
, r
= (uintptr_t)v
- 1;
1766 seq_putc(seq
, '\n');
1768 #define S3(fmt, s, v) \
1770 seq_printf(seq, "%-16s", s); \
1771 for (qs = 0; qs < n; ++qs) \
1772 seq_printf(seq, " %8" fmt, v); \
1773 seq_putc(seq, '\n'); \
1775 #define S(s, v) S3("s", s, v)
1777 #define T3(fmt, s, v) S3(fmt, s, txq[qs].v)
1778 #define T(s, v) T3("lu", s, v)
1780 #define R3(fmt, s, v) S3(fmt, s, rxq[qs].v)
1781 #define R(s, v) R3("lu", s, v)
1783 if (r
< eth_entries
) {
1784 const struct sge_eth_rxq
*rxq
= &adapter
->sge
.ethrxq
[r
* QPL
];
1785 const struct sge_eth_txq
*txq
= &adapter
->sge
.ethtxq
[r
* QPL
];
1786 int n
= min(QPL
, adapter
->sge
.ethqsets
- QPL
* r
);
1788 S("QType:", "Ethernet");
1790 (rxq
[qs
].rspq
.netdev
1791 ? rxq
[qs
].rspq
.netdev
->name
1793 R3("u", "RspQNullInts", rspq
.unhandled_irqs
);
1794 R("RxPackets:", stats
.pkts
);
1795 R("RxCSO:", stats
.rx_cso
);
1796 R("VLANxtract:", stats
.vlan_ex
);
1797 R("LROmerged:", stats
.lro_merged
);
1798 R("LROpackets:", stats
.lro_pkts
);
1799 R("RxDrops:", stats
.rx_drops
);
1801 T("TxCSO:", tx_cso
);
1802 T("VLANins:", vlan_ins
);
1803 T("TxQFull:", q
.stops
);
1804 T("TxQRestarts:", q
.restarts
);
1805 T("TxMapErr:", mapping_err
);
1806 R("FLAllocErr:", fl
.alloc_failed
);
1807 R("FLLrgAlcErr:", fl
.large_alloc_failed
);
1808 R("FLStarving:", fl
.starving
);
1814 const struct sge_rspq
*evtq
= &adapter
->sge
.fw_evtq
;
1816 seq_printf(seq
, "%-8s %16s\n", "QType:", "FW event queue");
1817 /* no real response queue statistics available to display */
1818 seq_printf(seq
, "%-16s %8u\n", "RspQ CIdx:", evtq
->cidx
);
1819 seq_printf(seq
, "%-16s %8u\n", "RspQ Gen:", evtq
->gen
);
1820 } else if (r
== 1) {
1821 const struct sge_rspq
*intrq
= &adapter
->sge
.intrq
;
1823 seq_printf(seq
, "%-8s %16s\n", "QType:", "Interrupt Queue");
1824 /* no real response queue statistics available to display */
1825 seq_printf(seq
, "%-16s %8u\n", "RspQ CIdx:", intrq
->cidx
);
1826 seq_printf(seq
, "%-16s %8u\n", "RspQ Gen:", intrq
->gen
);
1840 * Return the number of "entries" in our "file". We group the multi-Queue
1841 * sections with QPL Queue Sets per "entry". The sections of the output are:
1843 * Ethernet RX/TX Queue Sets
1844 * Firmware Event Queue
1845 * Forwarded Interrupt Queue (if in MSI mode)
1847 static int sge_qstats_entries(const struct adapter
*adapter
)
1849 return DIV_ROUND_UP(adapter
->sge
.ethqsets
, QPL
) + 1 +
1850 ((adapter
->flags
& USING_MSI
) != 0);
1853 static void *sge_qstats_start(struct seq_file
*seq
, loff_t
*pos
)
1855 int entries
= sge_qstats_entries(seq
->private);
1857 return *pos
< entries
? (void *)((uintptr_t)*pos
+ 1) : NULL
;
1860 static void sge_qstats_stop(struct seq_file
*seq
, void *v
)
1864 static void *sge_qstats_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1866 int entries
= sge_qstats_entries(seq
->private);
1869 return *pos
< entries
? (void *)((uintptr_t)*pos
+ 1) : NULL
;
1872 static const struct seq_operations sge_qstats_seq_ops
= {
1873 .start
= sge_qstats_start
,
1874 .next
= sge_qstats_next
,
1875 .stop
= sge_qstats_stop
,
1876 .show
= sge_qstats_show
1879 static int sge_qstats_open(struct inode
*inode
, struct file
*file
)
1881 int res
= seq_open(file
, &sge_qstats_seq_ops
);
1884 struct seq_file
*seq
= file
->private_data
;
1885 seq
->private = inode
->i_private
;
1890 static const struct file_operations sge_qstats_proc_fops
= {
1891 .owner
= THIS_MODULE
,
1892 .open
= sge_qstats_open
,
1894 .llseek
= seq_lseek
,
1895 .release
= seq_release
,
1899 * Show PCI-E SR-IOV Virtual Function Resource Limits.
1901 static int resources_show(struct seq_file
*seq
, void *v
)
1903 struct adapter
*adapter
= seq
->private;
1904 struct vf_resources
*vfres
= &adapter
->params
.vfres
;
1906 #define S(desc, fmt, var) \
1907 seq_printf(seq, "%-60s " fmt "\n", \
1908 desc " (" #var "):", vfres->var)
1910 S("Virtual Interfaces", "%d", nvi
);
1911 S("Egress Queues", "%d", neq
);
1912 S("Ethernet Control", "%d", nethctrl
);
1913 S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint
);
1914 S("Ingress Queues", "%d", niq
);
1915 S("Traffic Class", "%d", tc
);
1916 S("Port Access Rights Mask", "%#x", pmask
);
1917 S("MAC Address Filters", "%d", nexactf
);
1918 S("Firmware Command Read Capabilities", "%#x", r_caps
);
1919 S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps
);
1926 static int resources_open(struct inode
*inode
, struct file
*file
)
1928 return single_open(file
, resources_show
, inode
->i_private
);
1931 static const struct file_operations resources_proc_fops
= {
1932 .owner
= THIS_MODULE
,
1933 .open
= resources_open
,
1935 .llseek
= seq_lseek
,
1936 .release
= single_release
,
1940 * Show Virtual Interfaces.
1942 static int interfaces_show(struct seq_file
*seq
, void *v
)
1944 if (v
== SEQ_START_TOKEN
) {
1945 seq_puts(seq
, "Interface Port VIID\n");
1947 struct adapter
*adapter
= seq
->private;
1948 int pidx
= (uintptr_t)v
- 2;
1949 struct net_device
*dev
= adapter
->port
[pidx
];
1950 struct port_info
*pi
= netdev_priv(dev
);
1952 seq_printf(seq
, "%9s %4d %#5x\n",
1953 dev
->name
, pi
->port_id
, pi
->viid
);
1958 static inline void *interfaces_get_idx(struct adapter
*adapter
, loff_t pos
)
1960 return pos
<= adapter
->params
.nports
1961 ? (void *)(uintptr_t)(pos
+ 1)
1965 static void *interfaces_start(struct seq_file
*seq
, loff_t
*pos
)
1968 ? interfaces_get_idx(seq
->private, *pos
)
1972 static void *interfaces_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1975 return interfaces_get_idx(seq
->private, *pos
);
1978 static void interfaces_stop(struct seq_file
*seq
, void *v
)
1982 static const struct seq_operations interfaces_seq_ops
= {
1983 .start
= interfaces_start
,
1984 .next
= interfaces_next
,
1985 .stop
= interfaces_stop
,
1986 .show
= interfaces_show
1989 static int interfaces_open(struct inode
*inode
, struct file
*file
)
1991 int res
= seq_open(file
, &interfaces_seq_ops
);
1994 struct seq_file
*seq
= file
->private_data
;
1995 seq
->private = inode
->i_private
;
2000 static const struct file_operations interfaces_proc_fops
= {
2001 .owner
= THIS_MODULE
,
2002 .open
= interfaces_open
,
2004 .llseek
= seq_lseek
,
2005 .release
= seq_release
,
2009 * /sys/kernel/debugfs/cxgb4vf/ files list.
2011 struct cxgb4vf_debugfs_entry
{
2012 const char *name
; /* name of debugfs node */
2013 mode_t mode
; /* file system mode */
2014 const struct file_operations
*fops
;
2017 static struct cxgb4vf_debugfs_entry debugfs_files
[] = {
2018 { "sge_qinfo", S_IRUGO
, &sge_qinfo_debugfs_fops
},
2019 { "sge_qstats", S_IRUGO
, &sge_qstats_proc_fops
},
2020 { "resources", S_IRUGO
, &resources_proc_fops
},
2021 { "interfaces", S_IRUGO
, &interfaces_proc_fops
},
2025 * Module and device initialization and cleanup code.
2026 * ==================================================
2030 * Set up out /sys/kernel/debug/cxgb4vf sub-nodes. We assume that the
2031 * directory (debugfs_root) has already been set up.
2033 static int __devinit
setup_debugfs(struct adapter
*adapter
)
2037 BUG_ON(adapter
->debugfs_root
== NULL
);
2040 * Debugfs support is best effort.
2042 for (i
= 0; i
< ARRAY_SIZE(debugfs_files
); i
++)
2043 (void)debugfs_create_file(debugfs_files
[i
].name
,
2044 debugfs_files
[i
].mode
,
2045 adapter
->debugfs_root
,
2047 debugfs_files
[i
].fops
);
2053 * Tear down the /sys/kernel/debug/cxgb4vf sub-nodes created above. We leave
2054 * it to our caller to tear down the directory (debugfs_root).
2056 static void __devexit
cleanup_debugfs(struct adapter
*adapter
)
2058 BUG_ON(adapter
->debugfs_root
== NULL
);
2061 * Unlike our sister routine cleanup_proc(), we don't need to remove
2062 * individual entries because a call will be made to
2063 * debugfs_remove_recursive(). We just need to clean up any ancillary
2070 * Perform early "adapter" initialization. This is where we discover what
2071 * adapter parameters we're going to be using and initialize basic adapter
2074 static int adap_init0(struct adapter
*adapter
)
2076 struct vf_resources
*vfres
= &adapter
->params
.vfres
;
2077 struct sge_params
*sge_params
= &adapter
->params
.sge
;
2078 struct sge
*s
= &adapter
->sge
;
2079 unsigned int ethqsets
;
2083 * Wait for the device to become ready before proceeding ...
2085 err
= t4vf_wait_dev_ready(adapter
);
2087 dev_err(adapter
->pdev_dev
, "device didn't become ready:"
2093 * Grab basic operational parameters. These will predominantly have
2094 * been set up by the Physical Function Driver or will be hard coded
2095 * into the adapter. We just have to live with them ... Note that
2096 * we _must_ get our VPD parameters before our SGE parameters because
2097 * we need to know the adapter's core clock from the VPD in order to
2098 * properly decode the SGE Timer Values.
2100 err
= t4vf_get_dev_params(adapter
);
2102 dev_err(adapter
->pdev_dev
, "unable to retrieve adapter"
2103 " device parameters: err=%d\n", err
);
2106 err
= t4vf_get_vpd_params(adapter
);
2108 dev_err(adapter
->pdev_dev
, "unable to retrieve adapter"
2109 " VPD parameters: err=%d\n", err
);
2112 err
= t4vf_get_sge_params(adapter
);
2114 dev_err(adapter
->pdev_dev
, "unable to retrieve adapter"
2115 " SGE parameters: err=%d\n", err
);
2118 err
= t4vf_get_rss_glb_config(adapter
);
2120 dev_err(adapter
->pdev_dev
, "unable to retrieve adapter"
2121 " RSS parameters: err=%d\n", err
);
2124 if (adapter
->params
.rss
.mode
!=
2125 FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL
) {
2126 dev_err(adapter
->pdev_dev
, "unable to operate with global RSS"
2127 " mode %d\n", adapter
->params
.rss
.mode
);
2130 err
= t4vf_sge_init(adapter
);
2132 dev_err(adapter
->pdev_dev
, "unable to use adapter parameters:"
2138 * Retrieve our RX interrupt holdoff timer values and counter
2139 * threshold values from the SGE parameters.
2141 s
->timer_val
[0] = core_ticks_to_us(adapter
,
2142 TIMERVALUE0_GET(sge_params
->sge_timer_value_0_and_1
));
2143 s
->timer_val
[1] = core_ticks_to_us(adapter
,
2144 TIMERVALUE1_GET(sge_params
->sge_timer_value_0_and_1
));
2145 s
->timer_val
[2] = core_ticks_to_us(adapter
,
2146 TIMERVALUE0_GET(sge_params
->sge_timer_value_2_and_3
));
2147 s
->timer_val
[3] = core_ticks_to_us(adapter
,
2148 TIMERVALUE1_GET(sge_params
->sge_timer_value_2_and_3
));
2149 s
->timer_val
[4] = core_ticks_to_us(adapter
,
2150 TIMERVALUE0_GET(sge_params
->sge_timer_value_4_and_5
));
2151 s
->timer_val
[5] = core_ticks_to_us(adapter
,
2152 TIMERVALUE1_GET(sge_params
->sge_timer_value_4_and_5
));
2155 THRESHOLD_0_GET(sge_params
->sge_ingress_rx_threshold
);
2157 THRESHOLD_1_GET(sge_params
->sge_ingress_rx_threshold
);
2159 THRESHOLD_2_GET(sge_params
->sge_ingress_rx_threshold
);
2161 THRESHOLD_3_GET(sge_params
->sge_ingress_rx_threshold
);
2164 * Grab our Virtual Interface resource allocation, extract the
2165 * features that we're interested in and do a bit of sanity testing on
2168 err
= t4vf_get_vfres(adapter
);
2170 dev_err(adapter
->pdev_dev
, "unable to get virtual interface"
2171 " resources: err=%d\n", err
);
2176 * The number of "ports" which we support is equal to the number of
2177 * Virtual Interfaces with which we've been provisioned.
2179 adapter
->params
.nports
= vfres
->nvi
;
2180 if (adapter
->params
.nports
> MAX_NPORTS
) {
2181 dev_warn(adapter
->pdev_dev
, "only using %d of %d allowed"
2182 " virtual interfaces\n", MAX_NPORTS
,
2183 adapter
->params
.nports
);
2184 adapter
->params
.nports
= MAX_NPORTS
;
2188 * We need to reserve a number of the ingress queues with Free List
2189 * and Interrupt capabilities for special interrupt purposes (like
2190 * asynchronous firmware messages, or forwarded interrupts if we're
2191 * using MSI). The rest of the FL/Intr-capable ingress queues will be
2192 * matched up one-for-one with Ethernet/Control egress queues in order
2193 * to form "Queue Sets" which will be aportioned between the "ports".
2194 * For each Queue Set, we'll need the ability to allocate two Egress
2195 * Contexts -- one for the Ingress Queue Free List and one for the TX
2198 ethqsets
= vfres
->niqflint
- INGQ_EXTRAS
;
2199 if (vfres
->nethctrl
!= ethqsets
) {
2200 dev_warn(adapter
->pdev_dev
, "unequal number of [available]"
2201 " ingress/egress queues (%d/%d); using minimum for"
2202 " number of Queue Sets\n", ethqsets
, vfres
->nethctrl
);
2203 ethqsets
= min(vfres
->nethctrl
, ethqsets
);
2205 if (vfres
->neq
< ethqsets
*2) {
2206 dev_warn(adapter
->pdev_dev
, "Not enough Egress Contexts (%d)"
2207 " to support Queue Sets (%d); reducing allowed Queue"
2208 " Sets\n", vfres
->neq
, ethqsets
);
2209 ethqsets
= vfres
->neq
/2;
2211 if (ethqsets
> MAX_ETH_QSETS
) {
2212 dev_warn(adapter
->pdev_dev
, "only using %d of %d allowed Queue"
2213 " Sets\n", MAX_ETH_QSETS
, adapter
->sge
.max_ethqsets
);
2214 ethqsets
= MAX_ETH_QSETS
;
2216 if (vfres
->niq
!= 0 || vfres
->neq
> ethqsets
*2) {
2217 dev_warn(adapter
->pdev_dev
, "unused resources niq/neq (%d/%d)"
2218 " ignored\n", vfres
->niq
, vfres
->neq
- ethqsets
*2);
2220 adapter
->sge
.max_ethqsets
= ethqsets
;
2223 * Check for various parameter sanity issues. Most checks simply
2224 * result in us using fewer resources than our provissioning but we
2225 * do need at least one "port" with which to work ...
2227 if (adapter
->sge
.max_ethqsets
< adapter
->params
.nports
) {
2228 dev_warn(adapter
->pdev_dev
, "only using %d of %d available"
2229 " virtual interfaces (too few Queue Sets)\n",
2230 adapter
->sge
.max_ethqsets
, adapter
->params
.nports
);
2231 adapter
->params
.nports
= adapter
->sge
.max_ethqsets
;
2233 if (adapter
->params
.nports
== 0) {
2234 dev_err(adapter
->pdev_dev
, "no virtual interfaces configured/"
2241 static inline void init_rspq(struct sge_rspq
*rspq
, u8 timer_idx
,
2242 u8 pkt_cnt_idx
, unsigned int size
,
2243 unsigned int iqe_size
)
2245 rspq
->intr_params
= (QINTR_TIMER_IDX(timer_idx
) |
2246 (pkt_cnt_idx
< SGE_NCOUNTERS
? QINTR_CNT_EN
: 0));
2247 rspq
->pktcnt_idx
= (pkt_cnt_idx
< SGE_NCOUNTERS
2250 rspq
->iqe_len
= iqe_size
;
2255 * Perform default configuration of DMA queues depending on the number and
2256 * type of ports we found and the number of available CPUs. Most settings can
2257 * be modified by the admin via ethtool and cxgbtool prior to the adapter
2258 * being brought up for the first time.
2260 static void __devinit
cfg_queues(struct adapter
*adapter
)
2262 struct sge
*s
= &adapter
->sge
;
2263 int q10g
, n10g
, qidx
, pidx
, qs
;
2266 * We should not be called till we know how many Queue Sets we can
2267 * support. In particular, this means that we need to know what kind
2268 * of interrupts we'll be using ...
2270 BUG_ON((adapter
->flags
& (USING_MSIX
|USING_MSI
)) == 0);
2273 * Count the number of 10GbE Virtual Interfaces that we have.
2276 for_each_port(adapter
, pidx
)
2277 n10g
+= is_10g_port(&adap2pinfo(adapter
, pidx
)->link_cfg
);
2280 * We default to 1 queue per non-10G port and up to # of cores queues
2286 int n1g
= (adapter
->params
.nports
- n10g
);
2287 q10g
= (adapter
->sge
.max_ethqsets
- n1g
) / n10g
;
2288 if (q10g
> num_online_cpus())
2289 q10g
= num_online_cpus();
2293 * Allocate the "Queue Sets" to the various Virtual Interfaces.
2294 * The layout will be established in setup_sge_queues() when the
2295 * adapter is brough up for the first time.
2298 for_each_port(adapter
, pidx
) {
2299 struct port_info
*pi
= adap2pinfo(adapter
, pidx
);
2301 pi
->first_qset
= qidx
;
2302 pi
->nqsets
= is_10g_port(&pi
->link_cfg
) ? q10g
: 1;
2308 * Set up default Queue Set parameters ... Start off with the
2309 * shortest interrupt holdoff timer.
2311 for (qs
= 0; qs
< s
->max_ethqsets
; qs
++) {
2312 struct sge_eth_rxq
*rxq
= &s
->ethrxq
[qs
];
2313 struct sge_eth_txq
*txq
= &s
->ethtxq
[qs
];
2315 init_rspq(&rxq
->rspq
, 0, 0, 1024, L1_CACHE_BYTES
);
2321 * The firmware event queue is used for link state changes and
2322 * notifications of TX DMA completions.
2324 init_rspq(&s
->fw_evtq
, SGE_TIMER_RSTRT_CNTR
, 0, 512,
2328 * The forwarded interrupt queue is used when we're in MSI interrupt
2329 * mode. In this mode all interrupts associated with RX queues will
2330 * be forwarded to a single queue which we'll associate with our MSI
2331 * interrupt vector. The messages dropped in the forwarded interrupt
2332 * queue will indicate which ingress queue needs servicing ... This
2333 * queue needs to be large enough to accommodate all of the ingress
2334 * queues which are forwarding their interrupt (+1 to prevent the PIDX
2335 * from equalling the CIDX if every ingress queue has an outstanding
2336 * interrupt). The queue doesn't need to be any larger because no
2337 * ingress queue will ever have more than one outstanding interrupt at
2340 init_rspq(&s
->intrq
, SGE_TIMER_RSTRT_CNTR
, 0, MSIX_ENTRIES
+ 1,
2345 * Reduce the number of Ethernet queues across all ports to at most n.
2346 * n provides at least one queue per port.
2348 static void __devinit
reduce_ethqs(struct adapter
*adapter
, int n
)
2351 struct port_info
*pi
;
2354 * While we have too many active Ether Queue Sets, interate across the
2355 * "ports" and reduce their individual Queue Set allocations.
2357 BUG_ON(n
< adapter
->params
.nports
);
2358 while (n
< adapter
->sge
.ethqsets
)
2359 for_each_port(adapter
, i
) {
2360 pi
= adap2pinfo(adapter
, i
);
2361 if (pi
->nqsets
> 1) {
2363 adapter
->sge
.ethqsets
--;
2364 if (adapter
->sge
.ethqsets
<= n
)
2370 * Reassign the starting Queue Sets for each of the "ports" ...
2373 for_each_port(adapter
, i
) {
2374 pi
= adap2pinfo(adapter
, i
);
2381 * We need to grab enough MSI-X vectors to cover our interrupt needs. Ideally
2382 * we get a separate MSI-X vector for every "Queue Set" plus any extras we
2383 * need. Minimally we need one for every Virtual Interface plus those needed
2384 * for our "extras". Note that this process may lower the maximum number of
2385 * allowed Queue Sets ...
2387 static int __devinit
enable_msix(struct adapter
*adapter
)
2389 int i
, err
, want
, need
;
2390 struct msix_entry entries
[MSIX_ENTRIES
];
2391 struct sge
*s
= &adapter
->sge
;
2393 for (i
= 0; i
< MSIX_ENTRIES
; ++i
)
2394 entries
[i
].entry
= i
;
2397 * We _want_ enough MSI-X interrupts to cover all of our "Queue Sets"
2398 * plus those needed for our "extras" (for example, the firmware
2399 * message queue). We _need_ at least one "Queue Set" per Virtual
2400 * Interface plus those needed for our "extras". So now we get to see
2401 * if the song is right ...
2403 want
= s
->max_ethqsets
+ MSIX_EXTRAS
;
2404 need
= adapter
->params
.nports
+ MSIX_EXTRAS
;
2405 while ((err
= pci_enable_msix(adapter
->pdev
, entries
, want
)) >= need
)
2409 int nqsets
= want
- MSIX_EXTRAS
;
2410 if (nqsets
< s
->max_ethqsets
) {
2411 dev_warn(adapter
->pdev_dev
, "only enough MSI-X vectors"
2412 " for %d Queue Sets\n", nqsets
);
2413 s
->max_ethqsets
= nqsets
;
2414 if (nqsets
< s
->ethqsets
)
2415 reduce_ethqs(adapter
, nqsets
);
2417 for (i
= 0; i
< want
; ++i
)
2418 adapter
->msix_info
[i
].vec
= entries
[i
].vector
;
2419 } else if (err
> 0) {
2420 pci_disable_msix(adapter
->pdev
);
2421 dev_info(adapter
->pdev_dev
, "only %d MSI-X vectors left,"
2422 " not using MSI-X\n", err
);
2427 #ifdef HAVE_NET_DEVICE_OPS
2428 static const struct net_device_ops cxgb4vf_netdev_ops
= {
2429 .ndo_open
= cxgb4vf_open
,
2430 .ndo_stop
= cxgb4vf_stop
,
2431 .ndo_start_xmit
= t4vf_eth_xmit
,
2432 .ndo_get_stats
= cxgb4vf_get_stats
,
2433 .ndo_set_rx_mode
= cxgb4vf_set_rxmode
,
2434 .ndo_set_mac_address
= cxgb4vf_set_mac_addr
,
2435 .ndo_select_queue
= cxgb4vf_select_queue
,
2436 .ndo_validate_addr
= eth_validate_addr
,
2437 .ndo_do_ioctl
= cxgb4vf_do_ioctl
,
2438 .ndo_change_mtu
= cxgb4vf_change_mtu
,
2439 .ndo_vlan_rx_register
= cxgb4vf_vlan_rx_register
,
2440 #ifdef CONFIG_NET_POLL_CONTROLLER
2441 .ndo_poll_controller
= cxgb4vf_poll_controller
,
2447 * "Probe" a device: initialize a device and construct all kernel and driver
2448 * state needed to manage the device. This routine is called "init_one" in
2451 static int __devinit
cxgb4vf_pci_probe(struct pci_dev
*pdev
,
2452 const struct pci_device_id
*ent
)
2454 static int version_printed
;
2459 struct adapter
*adapter
;
2460 struct port_info
*pi
;
2461 struct net_device
*netdev
;
2464 * Vet our module parameters.
2466 if (msi
!= MSI_MSIX
&& msi
!= MSI_MSI
) {
2467 dev_err(&pdev
->dev
, "bad module parameter msi=%d; must be %d"
2468 " (MSI-X or MSI) or %d (MSI)\n", msi
, MSI_MSIX
,
2475 * Print our driver banner the first time we're called to initialize a
2478 if (version_printed
== 0) {
2479 printk(KERN_INFO
"%s - version %s\n", DRV_DESC
, DRV_VERSION
);
2480 version_printed
= 1;
2484 * Reserve PCI resources for the device. If we can't get them some
2485 * other driver may have already claimed the device ...
2487 err
= pci_request_regions(pdev
, KBUILD_MODNAME
);
2489 dev_err(&pdev
->dev
, "cannot obtain PCI resources\n");
2494 * Initialize generic PCI device state.
2496 err
= pci_enable_device(pdev
);
2498 dev_err(&pdev
->dev
, "cannot enable PCI device\n");
2499 goto err_release_regions
;
2503 * Set up our DMA mask: try for 64-bit address masking first and
2504 * fall back to 32-bit if we can't get 64 bits ...
2506 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(64));
2508 err
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64));
2510 dev_err(&pdev
->dev
, "unable to obtain 64-bit DMA for"
2511 " coherent allocations\n");
2512 goto err_disable_device
;
2516 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2518 dev_err(&pdev
->dev
, "no usable DMA configuration\n");
2519 goto err_disable_device
;
2525 * Enable bus mastering for the device ...
2527 pci_set_master(pdev
);
2530 * Allocate our adapter data structure and attach it to the device.
2532 adapter
= kzalloc(sizeof(*adapter
), GFP_KERNEL
);
2535 goto err_disable_device
;
2537 pci_set_drvdata(pdev
, adapter
);
2538 adapter
->pdev
= pdev
;
2539 adapter
->pdev_dev
= &pdev
->dev
;
2542 * Initialize SMP data synchronization resources.
2544 spin_lock_init(&adapter
->stats_lock
);
2547 * Map our I/O registers in BAR0.
2549 adapter
->regs
= pci_ioremap_bar(pdev
, 0);
2550 if (!adapter
->regs
) {
2551 dev_err(&pdev
->dev
, "cannot map device registers\n");
2553 goto err_free_adapter
;
2557 * Initialize adapter level features.
2559 adapter
->name
= pci_name(pdev
);
2560 adapter
->msg_enable
= dflt_msg_enable
;
2561 err
= adap_init0(adapter
);
2566 * Allocate our "adapter ports" and stitch everything together.
2568 pmask
= adapter
->params
.vfres
.pmask
;
2569 for_each_port(adapter
, pidx
) {
2573 * We simplistically allocate our virtual interfaces
2574 * sequentially across the port numbers to which we have
2575 * access rights. This should be configurable in some manner
2580 port_id
= ffs(pmask
) - 1;
2581 pmask
&= ~(1 << port_id
);
2582 viid
= t4vf_alloc_vi(adapter
, port_id
);
2584 dev_err(&pdev
->dev
, "cannot allocate VI for port %d:"
2585 " err=%d\n", port_id
, viid
);
2591 * Allocate our network device and stitch things together.
2593 netdev
= alloc_etherdev_mq(sizeof(struct port_info
),
2595 if (netdev
== NULL
) {
2596 dev_err(&pdev
->dev
, "cannot allocate netdev for"
2597 " port %d\n", port_id
);
2598 t4vf_free_vi(adapter
, viid
);
2602 adapter
->port
[pidx
] = netdev
;
2603 SET_NETDEV_DEV(netdev
, &pdev
->dev
);
2604 pi
= netdev_priv(netdev
);
2605 pi
->adapter
= adapter
;
2607 pi
->port_id
= port_id
;
2611 * Initialize the starting state of our "port" and register
2614 pi
->xact_addr_filt
= -1;
2615 pi
->rx_offload
= RX_CSO
;
2616 netif_carrier_off(netdev
);
2617 netif_tx_stop_all_queues(netdev
);
2618 netdev
->irq
= pdev
->irq
;
2620 netdev
->features
= (NETIF_F_SG
| NETIF_F_TSO
| NETIF_F_TSO6
|
2621 NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
|
2622 NETIF_F_HW_VLAN_TX
| NETIF_F_HW_VLAN_RX
|
2625 netdev
->features
|= NETIF_F_HIGHDMA
;
2626 netdev
->vlan_features
=
2628 ~(NETIF_F_HW_VLAN_TX
| NETIF_F_HW_VLAN_RX
));
2630 #ifdef HAVE_NET_DEVICE_OPS
2631 netdev
->netdev_ops
= &cxgb4vf_netdev_ops
;
2633 netdev
->vlan_rx_register
= cxgb4vf_vlan_rx_register
;
2634 netdev
->open
= cxgb4vf_open
;
2635 netdev
->stop
= cxgb4vf_stop
;
2636 netdev
->hard_start_xmit
= t4vf_eth_xmit
;
2637 netdev
->get_stats
= cxgb4vf_get_stats
;
2638 netdev
->set_rx_mode
= cxgb4vf_set_rxmode
;
2639 netdev
->do_ioctl
= cxgb4vf_do_ioctl
;
2640 netdev
->change_mtu
= cxgb4vf_change_mtu
;
2641 netdev
->set_mac_address
= cxgb4vf_set_mac_addr
;
2642 netdev
->select_queue
= cxgb4vf_select_queue
;
2643 #ifdef CONFIG_NET_POLL_CONTROLLER
2644 netdev
->poll_controller
= cxgb4vf_poll_controller
;
2647 SET_ETHTOOL_OPS(netdev
, &cxgb4vf_ethtool_ops
);
2650 * Initialize the hardware/software state for the port.
2652 err
= t4vf_port_init(adapter
, pidx
);
2654 dev_err(&pdev
->dev
, "cannot initialize port %d\n",
2661 * The "card" is now ready to go. If any errors occur during device
2662 * registration we do not fail the whole "card" but rather proceed
2663 * only with the ports we manage to register successfully. However we
2664 * must register at least one net device.
2666 for_each_port(adapter
, pidx
) {
2667 netdev
= adapter
->port
[pidx
];
2671 err
= register_netdev(netdev
);
2673 dev_warn(&pdev
->dev
, "cannot register net device %s,"
2674 " skipping\n", netdev
->name
);
2678 set_bit(pidx
, &adapter
->registered_device_map
);
2680 if (adapter
->registered_device_map
== 0) {
2681 dev_err(&pdev
->dev
, "could not register any net devices\n");
2686 * Set up our debugfs entries.
2688 if (cxgb4vf_debugfs_root
) {
2689 adapter
->debugfs_root
=
2690 debugfs_create_dir(pci_name(pdev
),
2691 cxgb4vf_debugfs_root
);
2692 if (adapter
->debugfs_root
== NULL
)
2693 dev_warn(&pdev
->dev
, "could not create debugfs"
2696 setup_debugfs(adapter
);
2700 * See what interrupts we'll be using. If we've been configured to
2701 * use MSI-X interrupts, try to enable them but fall back to using
2702 * MSI interrupts if we can't enable MSI-X interrupts. If we can't
2703 * get MSI interrupts we bail with the error.
2705 if (msi
== MSI_MSIX
&& enable_msix(adapter
) == 0)
2706 adapter
->flags
|= USING_MSIX
;
2708 err
= pci_enable_msi(pdev
);
2710 dev_err(&pdev
->dev
, "Unable to allocate %s interrupts;"
2712 msi
== MSI_MSIX
? "MSI-X or MSI" : "MSI", err
);
2713 goto err_free_debugfs
;
2715 adapter
->flags
|= USING_MSI
;
2719 * Now that we know how many "ports" we have and what their types are,
2720 * and how many Queue Sets we can support, we can configure our queue
2723 cfg_queues(adapter
);
2726 * Print a short notice on the existance and configuration of the new
2727 * VF network device ...
2729 for_each_port(adapter
, pidx
) {
2730 dev_info(adapter
->pdev_dev
, "%s: Chelsio VF NIC PCIe %s\n",
2731 adapter
->port
[pidx
]->name
,
2732 (adapter
->flags
& USING_MSIX
) ? "MSI-X" :
2733 (adapter
->flags
& USING_MSI
) ? "MSI" : "");
2742 * Error recovery and exit code. Unwind state that's been created
2743 * so far and return the error.
2747 if (adapter
->debugfs_root
) {
2748 cleanup_debugfs(adapter
);
2749 debugfs_remove_recursive(adapter
->debugfs_root
);
2753 for_each_port(adapter
, pidx
) {
2754 netdev
= adapter
->port
[pidx
];
2757 pi
= netdev_priv(netdev
);
2758 t4vf_free_vi(adapter
, pi
->viid
);
2759 if (test_bit(pidx
, &adapter
->registered_device_map
))
2760 unregister_netdev(netdev
);
2761 free_netdev(netdev
);
2765 iounmap(adapter
->regs
);
2769 pci_set_drvdata(pdev
, NULL
);
2772 pci_disable_device(pdev
);
2773 pci_clear_master(pdev
);
2775 err_release_regions
:
2776 pci_release_regions(pdev
);
2777 pci_set_drvdata(pdev
, NULL
);
2784 * "Remove" a device: tear down all kernel and driver state created in the
2785 * "probe" routine and quiesce the device (disable interrupts, etc.). (Note
2786 * that this is called "remove_one" in the PF Driver.)
2788 static void __devexit
cxgb4vf_pci_remove(struct pci_dev
*pdev
)
2790 struct adapter
*adapter
= pci_get_drvdata(pdev
);
2793 * Tear down driver state associated with device.
2799 * Stop all of our activity. Unregister network port,
2800 * disable interrupts, etc.
2802 for_each_port(adapter
, pidx
)
2803 if (test_bit(pidx
, &adapter
->registered_device_map
))
2804 unregister_netdev(adapter
->port
[pidx
]);
2805 t4vf_sge_stop(adapter
);
2806 if (adapter
->flags
& USING_MSIX
) {
2807 pci_disable_msix(adapter
->pdev
);
2808 adapter
->flags
&= ~USING_MSIX
;
2809 } else if (adapter
->flags
& USING_MSI
) {
2810 pci_disable_msi(adapter
->pdev
);
2811 adapter
->flags
&= ~USING_MSI
;
2815 * Tear down our debugfs entries.
2817 if (adapter
->debugfs_root
) {
2818 cleanup_debugfs(adapter
);
2819 debugfs_remove_recursive(adapter
->debugfs_root
);
2823 * Free all of the various resources which we've acquired ...
2825 t4vf_free_sge_resources(adapter
);
2826 for_each_port(adapter
, pidx
) {
2827 struct net_device
*netdev
= adapter
->port
[pidx
];
2828 struct port_info
*pi
;
2833 pi
= netdev_priv(netdev
);
2834 t4vf_free_vi(adapter
, pi
->viid
);
2835 free_netdev(netdev
);
2837 iounmap(adapter
->regs
);
2839 pci_set_drvdata(pdev
, NULL
);
2843 * Disable the device and release its PCI resources.
2845 pci_disable_device(pdev
);
2846 pci_clear_master(pdev
);
2847 pci_release_regions(pdev
);
2851 * PCI Device registration data structures.
2853 #define CH_DEVICE(devid, idx) \
2854 { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
2856 static struct pci_device_id cxgb4vf_pci_tbl
[] = {
2857 CH_DEVICE(0xb000, 0), /* PE10K FPGA */
2858 CH_DEVICE(0x4800, 0), /* T440-dbg */
2859 CH_DEVICE(0x4801, 0), /* T420-cr */
2860 CH_DEVICE(0x4802, 0), /* T422-cr */
2864 MODULE_DESCRIPTION(DRV_DESC
);
2865 MODULE_AUTHOR("Chelsio Communications");
2866 MODULE_LICENSE("Dual BSD/GPL");
2867 MODULE_VERSION(DRV_VERSION
);
2868 MODULE_DEVICE_TABLE(pci
, cxgb4vf_pci_tbl
);
2870 static struct pci_driver cxgb4vf_driver
= {
2871 .name
= KBUILD_MODNAME
,
2872 .id_table
= cxgb4vf_pci_tbl
,
2873 .probe
= cxgb4vf_pci_probe
,
2874 .remove
= __devexit_p(cxgb4vf_pci_remove
),
2878 * Initialize global driver state.
2880 static int __init
cxgb4vf_module_init(void)
2884 /* Debugfs support is optional, just warn if this fails */
2885 cxgb4vf_debugfs_root
= debugfs_create_dir(KBUILD_MODNAME
, NULL
);
2886 if (!cxgb4vf_debugfs_root
)
2887 printk(KERN_WARNING KBUILD_MODNAME
": could not create"
2888 " debugfs entry, continuing\n");
2890 ret
= pci_register_driver(&cxgb4vf_driver
);
2892 debugfs_remove(cxgb4vf_debugfs_root
);
2897 * Tear down global driver state.
2899 static void __exit
cxgb4vf_module_exit(void)
2901 pci_unregister_driver(&cxgb4vf_driver
);
2902 debugfs_remove(cxgb4vf_debugfs_root
);
2905 module_init(cxgb4vf_module_init
);
2906 module_exit(cxgb4vf_module_exit
);