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