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