Version:  2.0.40 2.2.26 2.4.37 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0

Linux/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us