cxgb4vf: Use netif_set_real_num_{rx, tx}_queues()
[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         netif_set_real_num_tx_queues(dev, pi->nqsets);
752         err = netif_set_real_num_rx_queues(dev, pi->nqsets);
753         if (err)
754                 return err;
755         set_bit(pi->port_id, &adapter->open_device_map);
756         link_start(dev);
757         netif_tx_start_all_queues(dev);
758         return 0;
759 }
760
761 /*
762  * Shut down a net device.  This routine is called "cxgb_close" in the PF
763  * Driver ...
764  */
765 static int cxgb4vf_stop(struct net_device *dev)
766 {
767         int ret;
768         struct port_info *pi = netdev_priv(dev);
769         struct adapter *adapter = pi->adapter;
770
771         netif_tx_stop_all_queues(dev);
772         netif_carrier_off(dev);
773         ret = t4vf_enable_vi(adapter, pi->viid, false, false);
774         pi->link_cfg.link_ok = 0;
775
776         clear_bit(pi->port_id, &adapter->open_device_map);
777         if (adapter->open_device_map == 0)
778                 adapter_down(adapter);
779         return 0;
780 }
781
782 /*
783  * Translate our basic statistics into the standard "ifconfig" statistics.
784  */
785 static struct net_device_stats *cxgb4vf_get_stats(struct net_device *dev)
786 {
787         struct t4vf_port_stats stats;
788         struct port_info *pi = netdev2pinfo(dev);
789         struct adapter *adapter = pi->adapter;
790         struct net_device_stats *ns = &dev->stats;
791         int err;
792
793         spin_lock(&adapter->stats_lock);
794         err = t4vf_get_port_stats(adapter, pi->pidx, &stats);
795         spin_unlock(&adapter->stats_lock);
796
797         memset(ns, 0, sizeof(*ns));
798         if (err)
799                 return ns;
800
801         ns->tx_bytes = (stats.tx_bcast_bytes + stats.tx_mcast_bytes +
802                         stats.tx_ucast_bytes + stats.tx_offload_bytes);
803         ns->tx_packets = (stats.tx_bcast_frames + stats.tx_mcast_frames +
804                           stats.tx_ucast_frames + stats.tx_offload_frames);
805         ns->rx_bytes = (stats.rx_bcast_bytes + stats.rx_mcast_bytes +
806                         stats.rx_ucast_bytes);
807         ns->rx_packets = (stats.rx_bcast_frames + stats.rx_mcast_frames +
808                           stats.rx_ucast_frames);
809         ns->multicast = stats.rx_mcast_frames;
810         ns->tx_errors = stats.tx_drop_frames;
811         ns->rx_errors = stats.rx_err_frames;
812
813         return ns;
814 }
815
816 /*
817  * Collect up to maxaddrs worth of a netdevice's unicast addresses into an
818  * array of addrss pointers and return the number collected.
819  */
820 static inline int collect_netdev_uc_list_addrs(const struct net_device *dev,
821                                                const u8 **addr,
822                                                unsigned int maxaddrs)
823 {
824         unsigned int naddr = 0;
825         const struct netdev_hw_addr *ha;
826
827         for_each_dev_addr(dev, ha) {
828                 addr[naddr++] = ha->addr;
829                 if (naddr >= maxaddrs)
830                         break;
831         }
832         return naddr;
833 }
834
835 /*
836  * Collect up to maxaddrs worth of a netdevice's multicast addresses into an
837  * array of addrss pointers and return the number collected.
838  */
839 static inline int collect_netdev_mc_list_addrs(const struct net_device *dev,
840                                                const u8 **addr,
841                                                unsigned int maxaddrs)
842 {
843         unsigned int naddr = 0;
844         const struct netdev_hw_addr *ha;
845
846         netdev_for_each_mc_addr(ha, dev) {
847                 addr[naddr++] = ha->addr;
848                 if (naddr >= maxaddrs)
849                         break;
850         }
851         return naddr;
852 }
853
854 /*
855  * Configure the exact and hash address filters to handle a port's multicast
856  * and secondary unicast MAC addresses.
857  */
858 static int set_addr_filters(const struct net_device *dev, bool sleep)
859 {
860         u64 mhash = 0;
861         u64 uhash = 0;
862         bool free = true;
863         u16 filt_idx[7];
864         const u8 *addr[7];
865         int ret, naddr = 0;
866         const struct port_info *pi = netdev_priv(dev);
867
868         /* first do the secondary unicast addresses */
869         naddr = collect_netdev_uc_list_addrs(dev, addr, ARRAY_SIZE(addr));
870         if (naddr > 0) {
871                 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
872                                           naddr, addr, filt_idx, &uhash, sleep);
873                 if (ret < 0)
874                         return ret;
875
876                 free = false;
877         }
878
879         /* next set up the multicast addresses */
880         naddr = collect_netdev_mc_list_addrs(dev, addr, ARRAY_SIZE(addr));
881         if (naddr > 0) {
882                 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free,
883                                           naddr, addr, filt_idx, &mhash, sleep);
884                 if (ret < 0)
885                         return ret;
886         }
887
888         return t4vf_set_addr_hash(pi->adapter, pi->viid, uhash != 0,
889                                   uhash | mhash, sleep);
890 }
891
892 /*
893  * Set RX properties of a port, such as promiscruity, address filters, and MTU.
894  * If @mtu is -1 it is left unchanged.
895  */
896 static int set_rxmode(struct net_device *dev, int mtu, bool sleep_ok)
897 {
898         int ret;
899         struct port_info *pi = netdev_priv(dev);
900
901         ret = set_addr_filters(dev, sleep_ok);
902         if (ret == 0)
903                 ret = t4vf_set_rxmode(pi->adapter, pi->viid, -1,
904                                       (dev->flags & IFF_PROMISC) != 0,
905                                       (dev->flags & IFF_ALLMULTI) != 0,
906                                       1, -1, sleep_ok);
907         return ret;
908 }
909
910 /*
911  * Set the current receive modes on the device.
912  */
913 static void cxgb4vf_set_rxmode(struct net_device *dev)
914 {
915         /* unfortunately we can't return errors to the stack */
916         set_rxmode(dev, -1, false);
917 }
918
919 /*
920  * Find the entry in the interrupt holdoff timer value array which comes
921  * closest to the specified interrupt holdoff value.
922  */
923 static int closest_timer(const struct sge *s, int us)
924 {
925         int i, timer_idx = 0, min_delta = INT_MAX;
926
927         for (i = 0; i < ARRAY_SIZE(s->timer_val); i++) {
928                 int delta = us - s->timer_val[i];
929                 if (delta < 0)
930                         delta = -delta;
931                 if (delta < min_delta) {
932                         min_delta = delta;
933                         timer_idx = i;
934                 }
935         }
936         return timer_idx;
937 }
938
939 static int closest_thres(const struct sge *s, int thres)
940 {
941         int i, delta, pktcnt_idx = 0, min_delta = INT_MAX;
942
943         for (i = 0; i < ARRAY_SIZE(s->counter_val); i++) {
944                 delta = thres - s->counter_val[i];
945                 if (delta < 0)
946                         delta = -delta;
947                 if (delta < min_delta) {
948                         min_delta = delta;
949                         pktcnt_idx = i;
950                 }
951         }
952         return pktcnt_idx;
953 }
954
955 /*
956  * Return a queue's interrupt hold-off time in us.  0 means no timer.
957  */
958 static unsigned int qtimer_val(const struct adapter *adapter,
959                                const struct sge_rspq *rspq)
960 {
961         unsigned int timer_idx = QINTR_TIMER_IDX_GET(rspq->intr_params);
962
963         return timer_idx < SGE_NTIMERS
964                 ? adapter->sge.timer_val[timer_idx]
965                 : 0;
966 }
967
968 /**
969  *      set_rxq_intr_params - set a queue's interrupt holdoff parameters
970  *      @adapter: the adapter
971  *      @rspq: the RX response queue
972  *      @us: the hold-off time in us, or 0 to disable timer
973  *      @cnt: the hold-off packet count, or 0 to disable counter
974  *
975  *      Sets an RX response queue's interrupt hold-off time and packet count.
976  *      At least one of the two needs to be enabled for the queue to generate
977  *      interrupts.
978  */
979 static int set_rxq_intr_params(struct adapter *adapter, struct sge_rspq *rspq,
980                                unsigned int us, unsigned int cnt)
981 {
982         unsigned int timer_idx;
983
984         /*
985          * If both the interrupt holdoff timer and count are specified as
986          * zero, default to a holdoff count of 1 ...
987          */
988         if ((us | cnt) == 0)
989                 cnt = 1;
990
991         /*
992          * If an interrupt holdoff count has been specified, then find the
993          * closest configured holdoff count and use that.  If the response
994          * queue has already been created, then update its queue context
995          * parameters ...
996          */
997         if (cnt) {
998                 int err;
999                 u32 v, pktcnt_idx;
1000
1001                 pktcnt_idx = closest_thres(&adapter->sge, cnt);
1002                 if (rspq->desc && rspq->pktcnt_idx != pktcnt_idx) {
1003                         v = FW_PARAMS_MNEM(FW_PARAMS_MNEM_DMAQ) |
1004                             FW_PARAMS_PARAM_X(
1005                                         FW_PARAMS_PARAM_DMAQ_IQ_INTCNTTHRESH) |
1006                             FW_PARAMS_PARAM_YZ(rspq->cntxt_id);
1007                         err = t4vf_set_params(adapter, 1, &v, &pktcnt_idx);
1008                         if (err)
1009                                 return err;
1010                 }
1011                 rspq->pktcnt_idx = pktcnt_idx;
1012         }
1013
1014         /*
1015          * Compute the closest holdoff timer index from the supplied holdoff
1016          * timer value.
1017          */
1018         timer_idx = (us == 0
1019                      ? SGE_TIMER_RSTRT_CNTR
1020                      : closest_timer(&adapter->sge, us));
1021
1022         /*
1023          * Update the response queue's interrupt coalescing parameters and
1024          * return success.
1025          */
1026         rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
1027                              (cnt > 0 ? QINTR_CNT_EN : 0));
1028         return 0;
1029 }
1030
1031 /*
1032  * Return a version number to identify the type of adapter.  The scheme is:
1033  * - bits 0..9: chip version
1034  * - bits 10..15: chip revision
1035  */
1036 static inline unsigned int mk_adap_vers(const struct adapter *adapter)
1037 {
1038         /*
1039          * Chip version 4, revision 0x3f (cxgb4vf).
1040          */
1041         return 4 | (0x3f << 10);
1042 }
1043
1044 /*
1045  * Execute the specified ioctl command.
1046  */
1047 static int cxgb4vf_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1048 {
1049         int ret = 0;
1050
1051         switch (cmd) {
1052             /*
1053              * The VF Driver doesn't have access to any of the other
1054              * common Ethernet device ioctl()'s (like reading/writing
1055              * PHY registers, etc.
1056              */
1057
1058         default:
1059                 ret = -EOPNOTSUPP;
1060                 break;
1061         }
1062         return ret;
1063 }
1064
1065 /*
1066  * Change the device's MTU.
1067  */
1068 static int cxgb4vf_change_mtu(struct net_device *dev, int new_mtu)
1069 {
1070         int ret;
1071         struct port_info *pi = netdev_priv(dev);
1072
1073         /* accommodate SACK */
1074         if (new_mtu < 81)
1075                 return -EINVAL;
1076
1077         ret = t4vf_set_rxmode(pi->adapter, pi->viid, new_mtu,
1078                               -1, -1, -1, -1, true);
1079         if (!ret)
1080                 dev->mtu = new_mtu;
1081         return ret;
1082 }
1083
1084 /*
1085  * Change the devices MAC address.
1086  */
1087 static int cxgb4vf_set_mac_addr(struct net_device *dev, void *_addr)
1088 {
1089         int ret;
1090         struct sockaddr *addr = _addr;
1091         struct port_info *pi = netdev_priv(dev);
1092
1093         if (!is_valid_ether_addr(addr->sa_data))
1094                 return -EINVAL;
1095
1096         ret = t4vf_change_mac(pi->adapter, pi->viid, pi->xact_addr_filt,
1097                               addr->sa_data, true);
1098         if (ret < 0)
1099                 return ret;
1100
1101         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1102         pi->xact_addr_filt = ret;
1103         return 0;
1104 }
1105
1106 /*
1107  * Return a TX Queue on which to send the specified skb.
1108  */
1109 static u16 cxgb4vf_select_queue(struct net_device *dev, struct sk_buff *skb)
1110 {
1111         /*
1112          * XXX For now just use the default hash but we probably want to
1113          * XXX look at other possibilities ...
1114          */
1115         return skb_tx_hash(dev, skb);
1116 }
1117
1118 #ifdef CONFIG_NET_POLL_CONTROLLER
1119 /*
1120  * Poll all of our receive queues.  This is called outside of normal interrupt
1121  * context.
1122  */
1123 static void cxgb4vf_poll_controller(struct net_device *dev)
1124 {
1125         struct port_info *pi = netdev_priv(dev);
1126         struct adapter *adapter = pi->adapter;
1127
1128         if (adapter->flags & USING_MSIX) {
1129                 struct sge_eth_rxq *rxq;
1130                 int nqsets;
1131
1132                 rxq = &adapter->sge.ethrxq[pi->first_qset];
1133                 for (nqsets = pi->nqsets; nqsets; nqsets--) {
1134                         t4vf_sge_intr_msix(0, &rxq->rspq);
1135                         rxq++;
1136                 }
1137         } else
1138                 t4vf_intr_handler(adapter)(0, adapter);
1139 }
1140 #endif
1141
1142 /*
1143  * Ethtool operations.
1144  * ===================
1145  *
1146  * Note that we don't support any ethtool operations which change the physical
1147  * state of the port to which we're linked.
1148  */
1149
1150 /*
1151  * Return current port link settings.
1152  */
1153 static int cxgb4vf_get_settings(struct net_device *dev,
1154                                 struct ethtool_cmd *cmd)
1155 {
1156         const struct port_info *pi = netdev_priv(dev);
1157
1158         cmd->supported = pi->link_cfg.supported;
1159         cmd->advertising = pi->link_cfg.advertising;
1160         cmd->speed = netif_carrier_ok(dev) ? pi->link_cfg.speed : -1;
1161         cmd->duplex = DUPLEX_FULL;
1162
1163         cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE;
1164         cmd->phy_address = pi->port_id;
1165         cmd->transceiver = XCVR_EXTERNAL;
1166         cmd->autoneg = pi->link_cfg.autoneg;
1167         cmd->maxtxpkt = 0;
1168         cmd->maxrxpkt = 0;
1169         return 0;
1170 }
1171
1172 /*
1173  * Return our driver information.
1174  */
1175 static void cxgb4vf_get_drvinfo(struct net_device *dev,
1176                                 struct ethtool_drvinfo *drvinfo)
1177 {
1178         struct adapter *adapter = netdev2adap(dev);
1179
1180         strcpy(drvinfo->driver, KBUILD_MODNAME);
1181         strcpy(drvinfo->version, DRV_VERSION);
1182         strcpy(drvinfo->bus_info, pci_name(to_pci_dev(dev->dev.parent)));
1183         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1184                  "%u.%u.%u.%u, TP %u.%u.%u.%u",
1185                  FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.fwrev),
1186                  FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.fwrev),
1187                  FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.fwrev),
1188                  FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.fwrev),
1189                  FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.tprev),
1190                  FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.tprev),
1191                  FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.tprev),
1192                  FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.tprev));
1193 }
1194
1195 /*
1196  * Return current adapter message level.
1197  */
1198 static u32 cxgb4vf_get_msglevel(struct net_device *dev)
1199 {
1200         return netdev2adap(dev)->msg_enable;
1201 }
1202
1203 /*
1204  * Set current adapter message level.
1205  */
1206 static void cxgb4vf_set_msglevel(struct net_device *dev, u32 msglevel)
1207 {
1208         netdev2adap(dev)->msg_enable = msglevel;
1209 }
1210
1211 /*
1212  * Return the device's current Queue Set ring size parameters along with the
1213  * allowed maximum values.  Since ethtool doesn't understand the concept of
1214  * multi-queue devices, we just return the current values associated with the
1215  * first Queue Set.
1216  */
1217 static void cxgb4vf_get_ringparam(struct net_device *dev,
1218                                   struct ethtool_ringparam *rp)
1219 {
1220         const struct port_info *pi = netdev_priv(dev);
1221         const struct sge *s = &pi->adapter->sge;
1222
1223         rp->rx_max_pending = MAX_RX_BUFFERS;
1224         rp->rx_mini_max_pending = MAX_RSPQ_ENTRIES;
1225         rp->rx_jumbo_max_pending = 0;
1226         rp->tx_max_pending = MAX_TXQ_ENTRIES;
1227
1228         rp->rx_pending = s->ethrxq[pi->first_qset].fl.size - MIN_FL_RESID;
1229         rp->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size;
1230         rp->rx_jumbo_pending = 0;
1231         rp->tx_pending = s->ethtxq[pi->first_qset].q.size;
1232 }
1233
1234 /*
1235  * Set the Queue Set ring size parameters for the device.  Again, since
1236  * ethtool doesn't allow for the concept of multiple queues per device, we'll
1237  * apply these new values across all of the Queue Sets associated with the
1238  * device -- after vetting them of course!
1239  */
1240 static int cxgb4vf_set_ringparam(struct net_device *dev,
1241                                  struct ethtool_ringparam *rp)
1242 {
1243         const struct port_info *pi = netdev_priv(dev);
1244         struct adapter *adapter = pi->adapter;
1245         struct sge *s = &adapter->sge;
1246         int qs;
1247
1248         if (rp->rx_pending > MAX_RX_BUFFERS ||
1249             rp->rx_jumbo_pending ||
1250             rp->tx_pending > MAX_TXQ_ENTRIES ||
1251             rp->rx_mini_pending > MAX_RSPQ_ENTRIES ||
1252             rp->rx_mini_pending < MIN_RSPQ_ENTRIES ||
1253             rp->rx_pending < MIN_FL_ENTRIES ||
1254             rp->tx_pending < MIN_TXQ_ENTRIES)
1255                 return -EINVAL;
1256
1257         if (adapter->flags & FULL_INIT_DONE)
1258                 return -EBUSY;
1259
1260         for (qs = pi->first_qset; qs < pi->first_qset + pi->nqsets; qs++) {
1261                 s->ethrxq[qs].fl.size = rp->rx_pending + MIN_FL_RESID;
1262                 s->ethrxq[qs].rspq.size = rp->rx_mini_pending;
1263                 s->ethtxq[qs].q.size = rp->tx_pending;
1264         }
1265         return 0;
1266 }
1267
1268 /*
1269  * Return the interrupt holdoff timer and count for the first Queue Set on the
1270  * device.  Our extension ioctl() (the cxgbtool interface) allows the
1271  * interrupt holdoff timer to be read on all of the device's Queue Sets.
1272  */
1273 static int cxgb4vf_get_coalesce(struct net_device *dev,
1274                                 struct ethtool_coalesce *coalesce)
1275 {
1276         const struct port_info *pi = netdev_priv(dev);
1277         const struct adapter *adapter = pi->adapter;
1278         const struct sge_rspq *rspq = &adapter->sge.ethrxq[pi->first_qset].rspq;
1279
1280         coalesce->rx_coalesce_usecs = qtimer_val(adapter, rspq);
1281         coalesce->rx_max_coalesced_frames =
1282                 ((rspq->intr_params & QINTR_CNT_EN)
1283                  ? adapter->sge.counter_val[rspq->pktcnt_idx]
1284                  : 0);
1285         return 0;
1286 }
1287
1288 /*
1289  * Set the RX interrupt holdoff timer and count for the first Queue Set on the
1290  * interface.  Our extension ioctl() (the cxgbtool interface) allows us to set
1291  * the interrupt holdoff timer on any of the device's Queue Sets.
1292  */
1293 static int cxgb4vf_set_coalesce(struct net_device *dev,
1294                                 struct ethtool_coalesce *coalesce)
1295 {
1296         const struct port_info *pi = netdev_priv(dev);
1297         struct adapter *adapter = pi->adapter;
1298
1299         return set_rxq_intr_params(adapter,
1300                                    &adapter->sge.ethrxq[pi->first_qset].rspq,
1301                                    coalesce->rx_coalesce_usecs,
1302                                    coalesce->rx_max_coalesced_frames);
1303 }
1304
1305 /*
1306  * Report current port link pause parameter settings.
1307  */
1308 static void cxgb4vf_get_pauseparam(struct net_device *dev,
1309                                    struct ethtool_pauseparam *pauseparam)
1310 {
1311         struct port_info *pi = netdev_priv(dev);
1312
1313         pauseparam->autoneg = (pi->link_cfg.requested_fc & PAUSE_AUTONEG) != 0;
1314         pauseparam->rx_pause = (pi->link_cfg.fc & PAUSE_RX) != 0;
1315         pauseparam->tx_pause = (pi->link_cfg.fc & PAUSE_TX) != 0;
1316 }
1317
1318 /*
1319  * Return whether RX Checksum Offloading is currently enabled for the device.
1320  */
1321 static u32 cxgb4vf_get_rx_csum(struct net_device *dev)
1322 {
1323         struct port_info *pi = netdev_priv(dev);
1324
1325         return (pi->rx_offload & RX_CSO) != 0;
1326 }
1327
1328 /*
1329  * Turn RX Checksum Offloading on or off for the device.
1330  */
1331 static int cxgb4vf_set_rx_csum(struct net_device *dev, u32 csum)
1332 {
1333         struct port_info *pi = netdev_priv(dev);
1334
1335         if (csum)
1336                 pi->rx_offload |= RX_CSO;
1337         else
1338                 pi->rx_offload &= ~RX_CSO;
1339         return 0;
1340 }
1341
1342 /*
1343  * Identify the port by blinking the port's LED.
1344  */
1345 static int cxgb4vf_phys_id(struct net_device *dev, u32 id)
1346 {
1347         struct port_info *pi = netdev_priv(dev);
1348
1349         return t4vf_identify_port(pi->adapter, pi->viid, 5);
1350 }
1351
1352 /*
1353  * Port stats maintained per queue of the port.
1354  */
1355 struct queue_port_stats {
1356         u64 tso;
1357         u64 tx_csum;
1358         u64 rx_csum;
1359         u64 vlan_ex;
1360         u64 vlan_ins;
1361 };
1362
1363 /*
1364  * Strings for the ETH_SS_STATS statistics set ("ethtool -S").  Note that
1365  * these need to match the order of statistics returned by
1366  * t4vf_get_port_stats().
1367  */
1368 static const char stats_strings[][ETH_GSTRING_LEN] = {
1369         /*
1370          * These must match the layout of the t4vf_port_stats structure.
1371          */
1372         "TxBroadcastBytes  ",
1373         "TxBroadcastFrames ",
1374         "TxMulticastBytes  ",
1375         "TxMulticastFrames ",
1376         "TxUnicastBytes    ",
1377         "TxUnicastFrames   ",
1378         "TxDroppedFrames   ",
1379         "TxOffloadBytes    ",
1380         "TxOffloadFrames   ",
1381         "RxBroadcastBytes  ",
1382         "RxBroadcastFrames ",
1383         "RxMulticastBytes  ",
1384         "RxMulticastFrames ",
1385         "RxUnicastBytes    ",
1386         "RxUnicastFrames   ",
1387         "RxErrorFrames     ",
1388
1389         /*
1390          * These are accumulated per-queue statistics and must match the
1391          * order of the fields in the queue_port_stats structure.
1392          */
1393         "TSO               ",
1394         "TxCsumOffload     ",
1395         "RxCsumGood        ",
1396         "VLANextractions   ",
1397         "VLANinsertions    ",
1398 };
1399
1400 /*
1401  * Return the number of statistics in the specified statistics set.
1402  */
1403 static int cxgb4vf_get_sset_count(struct net_device *dev, int sset)
1404 {
1405         switch (sset) {
1406         case ETH_SS_STATS:
1407                 return ARRAY_SIZE(stats_strings);
1408         default:
1409                 return -EOPNOTSUPP;
1410         }
1411         /*NOTREACHED*/
1412 }
1413
1414 /*
1415  * Return the strings for the specified statistics set.
1416  */
1417 static void cxgb4vf_get_strings(struct net_device *dev,
1418                                 u32 sset,
1419                                 u8 *data)
1420 {
1421         switch (sset) {
1422         case ETH_SS_STATS:
1423                 memcpy(data, stats_strings, sizeof(stats_strings));
1424                 break;
1425         }
1426 }
1427
1428 /*
1429  * Small utility routine to accumulate queue statistics across the queues of
1430  * a "port".
1431  */
1432 static void collect_sge_port_stats(const struct adapter *adapter,
1433                                    const struct port_info *pi,
1434                                    struct queue_port_stats *stats)
1435 {
1436         const struct sge_eth_txq *txq = &adapter->sge.ethtxq[pi->first_qset];
1437         const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset];
1438         int qs;
1439
1440         memset(stats, 0, sizeof(*stats));
1441         for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) {
1442                 stats->tso += txq->tso;
1443                 stats->tx_csum += txq->tx_cso;
1444                 stats->rx_csum += rxq->stats.rx_cso;
1445                 stats->vlan_ex += rxq->stats.vlan_ex;
1446                 stats->vlan_ins += txq->vlan_ins;
1447         }
1448 }
1449
1450 /*
1451  * Return the ETH_SS_STATS statistics set.
1452  */
1453 static void cxgb4vf_get_ethtool_stats(struct net_device *dev,
1454                                       struct ethtool_stats *stats,
1455                                       u64 *data)
1456 {
1457         struct port_info *pi = netdev2pinfo(dev);
1458         struct adapter *adapter = pi->adapter;
1459         int err = t4vf_get_port_stats(adapter, pi->pidx,
1460                                       (struct t4vf_port_stats *)data);
1461         if (err)
1462                 memset(data, 0, sizeof(struct t4vf_port_stats));
1463
1464         data += sizeof(struct t4vf_port_stats) / sizeof(u64);
1465         collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data);
1466 }
1467
1468 /*
1469  * Return the size of our register map.
1470  */
1471 static int cxgb4vf_get_regs_len(struct net_device *dev)
1472 {
1473         return T4VF_REGMAP_SIZE;
1474 }
1475
1476 /*
1477  * Dump a block of registers, start to end inclusive, into a buffer.
1478  */
1479 static void reg_block_dump(struct adapter *adapter, void *regbuf,
1480                            unsigned int start, unsigned int end)
1481 {
1482         u32 *bp = regbuf + start - T4VF_REGMAP_START;
1483
1484         for ( ; start <= end; start += sizeof(u32)) {
1485                 /*
1486                  * Avoid reading the Mailbox Control register since that
1487                  * can trigger a Mailbox Ownership Arbitration cycle and
1488                  * interfere with communication with the firmware.
1489                  */
1490                 if (start == T4VF_CIM_BASE_ADDR + CIM_VF_EXT_MAILBOX_CTRL)
1491                         *bp++ = 0xffff;
1492                 else
1493                         *bp++ = t4_read_reg(adapter, start);
1494         }
1495 }
1496
1497 /*
1498  * Copy our entire register map into the provided buffer.
1499  */
1500 static void cxgb4vf_get_regs(struct net_device *dev,
1501                              struct ethtool_regs *regs,
1502                              void *regbuf)
1503 {
1504         struct adapter *adapter = netdev2adap(dev);
1505
1506         regs->version = mk_adap_vers(adapter);
1507
1508         /*
1509          * Fill in register buffer with our register map.
1510          */
1511         memset(regbuf, 0, T4VF_REGMAP_SIZE);
1512
1513         reg_block_dump(adapter, regbuf,
1514                        T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_FIRST,
1515                        T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_LAST);
1516         reg_block_dump(adapter, regbuf,
1517                        T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_FIRST,
1518                        T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_LAST);
1519         reg_block_dump(adapter, regbuf,
1520                        T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_FIRST,
1521                        T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_LAST);
1522         reg_block_dump(adapter, regbuf,
1523                        T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_FIRST,
1524                        T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_LAST);
1525
1526         reg_block_dump(adapter, regbuf,
1527                        T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_FIRST,
1528                        T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_LAST);
1529 }
1530
1531 /*
1532  * Report current Wake On LAN settings.
1533  */
1534 static void cxgb4vf_get_wol(struct net_device *dev,
1535                             struct ethtool_wolinfo *wol)
1536 {
1537         wol->supported = 0;
1538         wol->wolopts = 0;
1539         memset(&wol->sopass, 0, sizeof(wol->sopass));
1540 }
1541
1542 /*
1543  * Set TCP Segmentation Offloading feature capabilities.
1544  */
1545 static int cxgb4vf_set_tso(struct net_device *dev, u32 tso)
1546 {
1547         if (tso)
1548                 dev->features |= NETIF_F_TSO | NETIF_F_TSO6;
1549         else
1550                 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
1551         return 0;
1552 }
1553
1554 static struct ethtool_ops cxgb4vf_ethtool_ops = {
1555         .get_settings           = cxgb4vf_get_settings,
1556         .get_drvinfo            = cxgb4vf_get_drvinfo,
1557         .get_msglevel           = cxgb4vf_get_msglevel,
1558         .set_msglevel           = cxgb4vf_set_msglevel,
1559         .get_ringparam          = cxgb4vf_get_ringparam,
1560         .set_ringparam          = cxgb4vf_set_ringparam,
1561         .get_coalesce           = cxgb4vf_get_coalesce,
1562         .set_coalesce           = cxgb4vf_set_coalesce,
1563         .get_pauseparam         = cxgb4vf_get_pauseparam,
1564         .get_rx_csum            = cxgb4vf_get_rx_csum,
1565         .set_rx_csum            = cxgb4vf_set_rx_csum,
1566         .set_tx_csum            = ethtool_op_set_tx_ipv6_csum,
1567         .set_sg                 = ethtool_op_set_sg,
1568         .get_link               = ethtool_op_get_link,
1569         .get_strings            = cxgb4vf_get_strings,
1570         .phys_id                = cxgb4vf_phys_id,
1571         .get_sset_count         = cxgb4vf_get_sset_count,
1572         .get_ethtool_stats      = cxgb4vf_get_ethtool_stats,
1573         .get_regs_len           = cxgb4vf_get_regs_len,
1574         .get_regs               = cxgb4vf_get_regs,
1575         .get_wol                = cxgb4vf_get_wol,
1576         .set_tso                = cxgb4vf_set_tso,
1577 };
1578
1579 /*
1580  * /sys/kernel/debug/cxgb4vf support code and data.
1581  * ================================================
1582  */
1583
1584 /*
1585  * Show SGE Queue Set information.  We display QPL Queues Sets per line.
1586  */
1587 #define QPL     4
1588
1589 static int sge_qinfo_show(struct seq_file *seq, void *v)
1590 {
1591         struct adapter *adapter = seq->private;
1592         int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1593         int qs, r = (uintptr_t)v - 1;
1594
1595         if (r)
1596                 seq_putc(seq, '\n');
1597
1598         #define S3(fmt_spec, s, v) \
1599                 do {\
1600                         seq_printf(seq, "%-12s", s); \
1601                         for (qs = 0; qs < n; ++qs) \
1602                                 seq_printf(seq, " %16" fmt_spec, v); \
1603                         seq_putc(seq, '\n'); \
1604                 } while (0)
1605         #define S(s, v)         S3("s", s, v)
1606         #define T(s, v)         S3("u", s, txq[qs].v)
1607         #define R(s, v)         S3("u", s, rxq[qs].v)
1608
1609         if (r < eth_entries) {
1610                 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1611                 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1612                 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1613
1614                 S("QType:", "Ethernet");
1615                 S("Interface:",
1616                   (rxq[qs].rspq.netdev
1617                    ? rxq[qs].rspq.netdev->name
1618                    : "N/A"));
1619                 S3("d", "Port:",
1620                    (rxq[qs].rspq.netdev
1621                     ? ((struct port_info *)
1622                        netdev_priv(rxq[qs].rspq.netdev))->port_id
1623                     : -1));
1624                 T("TxQ ID:", q.abs_id);
1625                 T("TxQ size:", q.size);
1626                 T("TxQ inuse:", q.in_use);
1627                 T("TxQ PIdx:", q.pidx);
1628                 T("TxQ CIdx:", q.cidx);
1629                 R("RspQ ID:", rspq.abs_id);
1630                 R("RspQ size:", rspq.size);
1631                 R("RspQE size:", rspq.iqe_len);
1632                 S3("u", "Intr delay:", qtimer_val(adapter, &rxq[qs].rspq));
1633                 S3("u", "Intr pktcnt:",
1634                    adapter->sge.counter_val[rxq[qs].rspq.pktcnt_idx]);
1635                 R("RspQ CIdx:", rspq.cidx);
1636                 R("RspQ Gen:", rspq.gen);
1637                 R("FL ID:", fl.abs_id);
1638                 R("FL size:", fl.size - MIN_FL_RESID);
1639                 R("FL avail:", fl.avail);
1640                 R("FL PIdx:", fl.pidx);
1641                 R("FL CIdx:", fl.cidx);
1642                 return 0;
1643         }
1644
1645         r -= eth_entries;
1646         if (r == 0) {
1647                 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1648
1649                 seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue");
1650                 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id);
1651                 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1652                            qtimer_val(adapter, evtq));
1653                 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1654                            adapter->sge.counter_val[evtq->pktcnt_idx]);
1655                 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", evtq->cidx);
1656                 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen);
1657         } else if (r == 1) {
1658                 const struct sge_rspq *intrq = &adapter->sge.intrq;
1659
1660                 seq_printf(seq, "%-12s %16s\n", "QType:", "Interrupt Queue");
1661                 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", intrq->abs_id);
1662                 seq_printf(seq, "%-12s %16u\n", "Intr delay:",
1663                            qtimer_val(adapter, intrq));
1664                 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
1665                            adapter->sge.counter_val[intrq->pktcnt_idx]);
1666                 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", intrq->cidx);
1667                 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", intrq->gen);
1668         }
1669
1670         #undef R
1671         #undef T
1672         #undef S
1673         #undef S3
1674
1675         return 0;
1676 }
1677
1678 /*
1679  * Return the number of "entries" in our "file".  We group the multi-Queue
1680  * sections with QPL Queue Sets per "entry".  The sections of the output are:
1681  *
1682  *     Ethernet RX/TX Queue Sets
1683  *     Firmware Event Queue
1684  *     Forwarded Interrupt Queue (if in MSI mode)
1685  */
1686 static int sge_queue_entries(const struct adapter *adapter)
1687 {
1688         return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1689                 ((adapter->flags & USING_MSI) != 0);
1690 }
1691
1692 static void *sge_queue_start(struct seq_file *seq, loff_t *pos)
1693 {
1694         int entries = sge_queue_entries(seq->private);
1695
1696         return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1697 }
1698
1699 static void sge_queue_stop(struct seq_file *seq, void *v)
1700 {
1701 }
1702
1703 static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos)
1704 {
1705         int entries = sge_queue_entries(seq->private);
1706
1707         ++*pos;
1708         return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1709 }
1710
1711 static const struct seq_operations sge_qinfo_seq_ops = {
1712         .start = sge_queue_start,
1713         .next  = sge_queue_next,
1714         .stop  = sge_queue_stop,
1715         .show  = sge_qinfo_show
1716 };
1717
1718 static int sge_qinfo_open(struct inode *inode, struct file *file)
1719 {
1720         int res = seq_open(file, &sge_qinfo_seq_ops);
1721
1722         if (!res) {
1723                 struct seq_file *seq = file->private_data;
1724                 seq->private = inode->i_private;
1725         }
1726         return res;
1727 }
1728
1729 static const struct file_operations sge_qinfo_debugfs_fops = {
1730         .owner   = THIS_MODULE,
1731         .open    = sge_qinfo_open,
1732         .read    = seq_read,
1733         .llseek  = seq_lseek,
1734         .release = seq_release,
1735 };
1736
1737 /*
1738  * Show SGE Queue Set statistics.  We display QPL Queues Sets per line.
1739  */
1740 #define QPL     4
1741
1742 static int sge_qstats_show(struct seq_file *seq, void *v)
1743 {
1744         struct adapter *adapter = seq->private;
1745         int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);
1746         int qs, r = (uintptr_t)v - 1;
1747
1748         if (r)
1749                 seq_putc(seq, '\n');
1750
1751         #define S3(fmt, s, v) \
1752                 do { \
1753                         seq_printf(seq, "%-16s", s); \
1754                         for (qs = 0; qs < n; ++qs) \
1755                                 seq_printf(seq, " %8" fmt, v); \
1756                         seq_putc(seq, '\n'); \
1757                 } while (0)
1758         #define S(s, v)         S3("s", s, v)
1759
1760         #define T3(fmt, s, v)   S3(fmt, s, txq[qs].v)
1761         #define T(s, v)         T3("lu", s, v)
1762
1763         #define R3(fmt, s, v)   S3(fmt, s, rxq[qs].v)
1764         #define R(s, v)         R3("lu", s, v)
1765
1766         if (r < eth_entries) {
1767                 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL];
1768                 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL];
1769                 int n = min(QPL, adapter->sge.ethqsets - QPL * r);
1770
1771                 S("QType:", "Ethernet");
1772                 S("Interface:",
1773                   (rxq[qs].rspq.netdev
1774                    ? rxq[qs].rspq.netdev->name
1775                    : "N/A"));
1776                 R3("u", "RspQNullInts:", rspq.unhandled_irqs);
1777                 R("RxPackets:", stats.pkts);
1778                 R("RxCSO:", stats.rx_cso);
1779                 R("VLANxtract:", stats.vlan_ex);
1780                 R("LROmerged:", stats.lro_merged);
1781                 R("LROpackets:", stats.lro_pkts);
1782                 R("RxDrops:", stats.rx_drops);
1783                 T("TSO:", tso);
1784                 T("TxCSO:", tx_cso);
1785                 T("VLANins:", vlan_ins);
1786                 T("TxQFull:", q.stops);
1787                 T("TxQRestarts:", q.restarts);
1788                 T("TxMapErr:", mapping_err);
1789                 R("FLAllocErr:", fl.alloc_failed);
1790                 R("FLLrgAlcErr:", fl.large_alloc_failed);
1791                 R("FLStarving:", fl.starving);
1792                 return 0;
1793         }
1794
1795         r -= eth_entries;
1796         if (r == 0) {
1797                 const struct sge_rspq *evtq = &adapter->sge.fw_evtq;
1798
1799                 seq_printf(seq, "%-8s %16s\n", "QType:", "FW event queue");
1800                 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1801                            evtq->unhandled_irqs);
1802                 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", evtq->cidx);
1803                 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", evtq->gen);
1804         } else if (r == 1) {
1805                 const struct sge_rspq *intrq = &adapter->sge.intrq;
1806
1807                 seq_printf(seq, "%-8s %16s\n", "QType:", "Interrupt Queue");
1808                 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:",
1809                            intrq->unhandled_irqs);
1810                 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", intrq->cidx);
1811                 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", intrq->gen);
1812         }
1813
1814         #undef R
1815         #undef T
1816         #undef S
1817         #undef R3
1818         #undef T3
1819         #undef S3
1820
1821         return 0;
1822 }
1823
1824 /*
1825  * Return the number of "entries" in our "file".  We group the multi-Queue
1826  * sections with QPL Queue Sets per "entry".  The sections of the output are:
1827  *
1828  *     Ethernet RX/TX Queue Sets
1829  *     Firmware Event Queue
1830  *     Forwarded Interrupt Queue (if in MSI mode)
1831  */
1832 static int sge_qstats_entries(const struct adapter *adapter)
1833 {
1834         return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +
1835                 ((adapter->flags & USING_MSI) != 0);
1836 }
1837
1838 static void *sge_qstats_start(struct seq_file *seq, loff_t *pos)
1839 {
1840         int entries = sge_qstats_entries(seq->private);
1841
1842         return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1843 }
1844
1845 static void sge_qstats_stop(struct seq_file *seq, void *v)
1846 {
1847 }
1848
1849 static void *sge_qstats_next(struct seq_file *seq, void *v, loff_t *pos)
1850 {
1851         int entries = sge_qstats_entries(seq->private);
1852
1853         (*pos)++;
1854         return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
1855 }
1856
1857 static const struct seq_operations sge_qstats_seq_ops = {
1858         .start = sge_qstats_start,
1859         .next  = sge_qstats_next,
1860         .stop  = sge_qstats_stop,
1861         .show  = sge_qstats_show
1862 };
1863
1864 static int sge_qstats_open(struct inode *inode, struct file *file)
1865 {
1866         int res = seq_open(file, &sge_qstats_seq_ops);
1867
1868         if (res == 0) {
1869                 struct seq_file *seq = file->private_data;
1870                 seq->private = inode->i_private;
1871         }
1872         return res;
1873 }
1874
1875 static const struct file_operations sge_qstats_proc_fops = {
1876         .owner   = THIS_MODULE,
1877         .open    = sge_qstats_open,
1878         .read    = seq_read,
1879         .llseek  = seq_lseek,
1880         .release = seq_release,
1881 };
1882
1883 /*
1884  * Show PCI-E SR-IOV Virtual Function Resource Limits.
1885  */
1886 static int resources_show(struct seq_file *seq, void *v)
1887 {
1888         struct adapter *adapter = seq->private;
1889         struct vf_resources *vfres = &adapter->params.vfres;
1890
1891         #define S(desc, fmt, var) \
1892                 seq_printf(seq, "%-60s " fmt "\n", \
1893                            desc " (" #var "):", vfres->var)
1894
1895         S("Virtual Interfaces", "%d", nvi);
1896         S("Egress Queues", "%d", neq);
1897         S("Ethernet Control", "%d", nethctrl);
1898         S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint);
1899         S("Ingress Queues", "%d", niq);
1900         S("Traffic Class", "%d", tc);
1901         S("Port Access Rights Mask", "%#x", pmask);
1902         S("MAC Address Filters", "%d", nexactf);
1903         S("Firmware Command Read Capabilities", "%#x", r_caps);
1904         S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps);
1905
1906         #undef S
1907
1908         return 0;
1909 }
1910
1911 static int resources_open(struct inode *inode, struct file *file)
1912 {
1913         return single_open(file, resources_show, inode->i_private);
1914 }
1915
1916 static const struct file_operations resources_proc_fops = {
1917         .owner   = THIS_MODULE,
1918         .open    = resources_open,
1919         .read    = seq_read,
1920         .llseek  = seq_lseek,
1921         .release = single_release,
1922 };
1923
1924 /*
1925  * Show Virtual Interfaces.
1926  */
1927 static int interfaces_show(struct seq_file *seq, void *v)
1928 {
1929         if (v == SEQ_START_TOKEN) {
1930                 seq_puts(seq, "Interface  Port   VIID\n");
1931         } else {
1932                 struct adapter *adapter = seq->private;
1933                 int pidx = (uintptr_t)v - 2;
1934                 struct net_device *dev = adapter->port[pidx];
1935                 struct port_info *pi = netdev_priv(dev);
1936
1937                 seq_printf(seq, "%9s  %4d  %#5x\n",
1938                            dev->name, pi->port_id, pi->viid);
1939         }
1940         return 0;
1941 }
1942
1943 static inline void *interfaces_get_idx(struct adapter *adapter, loff_t pos)
1944 {
1945         return pos <= adapter->params.nports
1946                 ? (void *)(uintptr_t)(pos + 1)
1947                 : NULL;
1948 }
1949
1950 static void *interfaces_start(struct seq_file *seq, loff_t *pos)
1951 {
1952         return *pos
1953                 ? interfaces_get_idx(seq->private, *pos)
1954                 : SEQ_START_TOKEN;
1955 }
1956
1957 static void *interfaces_next(struct seq_file *seq, void *v, loff_t *pos)
1958 {
1959         (*pos)++;
1960         return interfaces_get_idx(seq->private, *pos);
1961 }
1962
1963 static void interfaces_stop(struct seq_file *seq, void *v)
1964 {
1965 }
1966
1967 static const struct seq_operations interfaces_seq_ops = {
1968         .start = interfaces_start,
1969         .next  = interfaces_next,
1970         .stop  = interfaces_stop,
1971         .show  = interfaces_show
1972 };
1973
1974 static int interfaces_open(struct inode *inode, struct file *file)
1975 {
1976         int res = seq_open(file, &interfaces_seq_ops);
1977
1978         if (res == 0) {
1979                 struct seq_file *seq = file->private_data;
1980                 seq->private = inode->i_private;
1981         }
1982         return res;
1983 }
1984
1985 static const struct file_operations interfaces_proc_fops = {
1986         .owner   = THIS_MODULE,
1987         .open    = interfaces_open,
1988         .read    = seq_read,
1989         .llseek  = seq_lseek,
1990         .release = seq_release,
1991 };
1992
1993 /*
1994  * /sys/kernel/debugfs/cxgb4vf/ files list.
1995  */
1996 struct cxgb4vf_debugfs_entry {
1997         const char *name;               /* name of debugfs node */
1998         mode_t mode;                    /* file system mode */
1999         const struct file_operations *fops;
2000 };
2001
2002 static struct cxgb4vf_debugfs_entry debugfs_files[] = {
2003         { "sge_qinfo",  S_IRUGO, &sge_qinfo_debugfs_fops },
2004         { "sge_qstats", S_IRUGO, &sge_qstats_proc_fops },
2005         { "resources",  S_IRUGO, &resources_proc_fops },
2006         { "interfaces", S_IRUGO, &interfaces_proc_fops },
2007 };
2008
2009 /*
2010  * Module and device initialization and cleanup code.
2011  * ==================================================
2012  */
2013
2014 /*
2015  * Set up out /sys/kernel/debug/cxgb4vf sub-nodes.  We assume that the
2016  * directory (debugfs_root) has already been set up.
2017  */
2018 static int __devinit setup_debugfs(struct adapter *adapter)
2019 {
2020         int i;
2021
2022         BUG_ON(adapter->debugfs_root == NULL);
2023
2024         /*
2025          * Debugfs support is best effort.
2026          */
2027         for (i = 0; i < ARRAY_SIZE(debugfs_files); i++)
2028                 (void)debugfs_create_file(debugfs_files[i].name,
2029                                   debugfs_files[i].mode,
2030                                   adapter->debugfs_root,
2031                                   (void *)adapter,
2032                                   debugfs_files[i].fops);
2033
2034         return 0;
2035 }
2036
2037 /*
2038  * Tear down the /sys/kernel/debug/cxgb4vf sub-nodes created above.  We leave
2039  * it to our caller to tear down the directory (debugfs_root).
2040  */
2041 static void __devexit cleanup_debugfs(struct adapter *adapter)
2042 {
2043         BUG_ON(adapter->debugfs_root == NULL);
2044
2045         /*
2046          * Unlike our sister routine cleanup_proc(), we don't need to remove
2047          * individual entries because a call will be made to
2048          * debugfs_remove_recursive().  We just need to clean up any ancillary
2049          * persistent state.
2050          */
2051         /* nothing to do */
2052 }
2053
2054 /*
2055  * Perform early "adapter" initialization.  This is where we discover what
2056  * adapter parameters we're going to be using and initialize basic adapter
2057  * hardware support.
2058  */
2059 static int adap_init0(struct adapter *adapter)
2060 {
2061         struct vf_resources *vfres = &adapter->params.vfres;
2062         struct sge_params *sge_params = &adapter->params.sge;
2063         struct sge *s = &adapter->sge;
2064         unsigned int ethqsets;
2065         int err;
2066
2067         /*
2068          * Wait for the device to become ready before proceeding ...
2069          */
2070         err = t4vf_wait_dev_ready(adapter);
2071         if (err) {
2072                 dev_err(adapter->pdev_dev, "device didn't become ready:"
2073                         " err=%d\n", err);
2074                 return err;
2075         }
2076
2077         /*
2078          * Grab basic operational parameters.  These will predominantly have
2079          * been set up by the Physical Function Driver or will be hard coded
2080          * into the adapter.  We just have to live with them ...  Note that
2081          * we _must_ get our VPD parameters before our SGE parameters because
2082          * we need to know the adapter's core clock from the VPD in order to
2083          * properly decode the SGE Timer Values.
2084          */
2085         err = t4vf_get_dev_params(adapter);
2086         if (err) {
2087                 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2088                         " device parameters: err=%d\n", err);
2089                 return err;
2090         }
2091         err = t4vf_get_vpd_params(adapter);
2092         if (err) {
2093                 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2094                         " VPD parameters: err=%d\n", err);
2095                 return err;
2096         }
2097         err = t4vf_get_sge_params(adapter);
2098         if (err) {
2099                 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2100                         " SGE parameters: err=%d\n", err);
2101                 return err;
2102         }
2103         err = t4vf_get_rss_glb_config(adapter);
2104         if (err) {
2105                 dev_err(adapter->pdev_dev, "unable to retrieve adapter"
2106                         " RSS parameters: err=%d\n", err);
2107                 return err;
2108         }
2109         if (adapter->params.rss.mode !=
2110             FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
2111                 dev_err(adapter->pdev_dev, "unable to operate with global RSS"
2112                         " mode %d\n", adapter->params.rss.mode);
2113                 return -EINVAL;
2114         }
2115         err = t4vf_sge_init(adapter);
2116         if (err) {
2117                 dev_err(adapter->pdev_dev, "unable to use adapter parameters:"
2118                         " err=%d\n", err);
2119                 return err;
2120         }
2121
2122         /*
2123          * Retrieve our RX interrupt holdoff timer values and counter
2124          * threshold values from the SGE parameters.
2125          */
2126         s->timer_val[0] = core_ticks_to_us(adapter,
2127                 TIMERVALUE0_GET(sge_params->sge_timer_value_0_and_1));
2128         s->timer_val[1] = core_ticks_to_us(adapter,
2129                 TIMERVALUE1_GET(sge_params->sge_timer_value_0_and_1));
2130         s->timer_val[2] = core_ticks_to_us(adapter,
2131                 TIMERVALUE0_GET(sge_params->sge_timer_value_2_and_3));
2132         s->timer_val[3] = core_ticks_to_us(adapter,
2133                 TIMERVALUE1_GET(sge_params->sge_timer_value_2_and_3));
2134         s->timer_val[4] = core_ticks_to_us(adapter,
2135                 TIMERVALUE0_GET(sge_params->sge_timer_value_4_and_5));
2136         s->timer_val[5] = core_ticks_to_us(adapter,
2137                 TIMERVALUE1_GET(sge_params->sge_timer_value_4_and_5));
2138
2139         s->counter_val[0] =
2140                 THRESHOLD_0_GET(sge_params->sge_ingress_rx_threshold);
2141         s->counter_val[1] =
2142                 THRESHOLD_1_GET(sge_params->sge_ingress_rx_threshold);
2143         s->counter_val[2] =
2144                 THRESHOLD_2_GET(sge_params->sge_ingress_rx_threshold);
2145         s->counter_val[3] =
2146                 THRESHOLD_3_GET(sge_params->sge_ingress_rx_threshold);
2147
2148         /*
2149          * Grab our Virtual Interface resource allocation, extract the
2150          * features that we're interested in and do a bit of sanity testing on
2151          * what we discover.
2152          */
2153         err = t4vf_get_vfres(adapter);
2154         if (err) {
2155                 dev_err(adapter->pdev_dev, "unable to get virtual interface"
2156                         " resources: err=%d\n", err);
2157                 return err;
2158         }
2159
2160         /*
2161          * The number of "ports" which we support is equal to the number of
2162          * Virtual Interfaces with which we've been provisioned.
2163          */
2164         adapter->params.nports = vfres->nvi;
2165         if (adapter->params.nports > MAX_NPORTS) {
2166                 dev_warn(adapter->pdev_dev, "only using %d of %d allowed"
2167                          " virtual interfaces\n", MAX_NPORTS,
2168                          adapter->params.nports);
2169                 adapter->params.nports = MAX_NPORTS;
2170         }
2171
2172         /*
2173          * We need to reserve a number of the ingress queues with Free List
2174          * and Interrupt capabilities for special interrupt purposes (like
2175          * asynchronous firmware messages, or forwarded interrupts if we're
2176          * using MSI).  The rest of the FL/Intr-capable ingress queues will be
2177          * matched up one-for-one with Ethernet/Control egress queues in order
2178          * to form "Queue Sets" which will be aportioned between the "ports".
2179          * For each Queue Set, we'll need the ability to allocate two Egress
2180          * Contexts -- one for the Ingress Queue Free List and one for the TX
2181          * Ethernet Queue.
2182          */
2183         ethqsets = vfres->niqflint - INGQ_EXTRAS;
2184         if (vfres->nethctrl != ethqsets) {
2185                 dev_warn(adapter->pdev_dev, "unequal number of [available]"
2186                          " ingress/egress queues (%d/%d); using minimum for"
2187                          " number of Queue Sets\n", ethqsets, vfres->nethctrl);
2188                 ethqsets = min(vfres->nethctrl, ethqsets);
2189         }
2190         if (vfres->neq < ethqsets*2) {
2191                 dev_warn(adapter->pdev_dev, "Not enough Egress Contexts (%d)"
2192                          " to support Queue Sets (%d); reducing allowed Queue"
2193                          " Sets\n", vfres->neq, ethqsets);
2194                 ethqsets = vfres->neq/2;
2195         }
2196         if (ethqsets > MAX_ETH_QSETS) {
2197                 dev_warn(adapter->pdev_dev, "only using %d of %d allowed Queue"
2198                          " Sets\n", MAX_ETH_QSETS, adapter->sge.max_ethqsets);
2199                 ethqsets = MAX_ETH_QSETS;
2200         }
2201         if (vfres->niq != 0 || vfres->neq > ethqsets*2) {
2202                 dev_warn(adapter->pdev_dev, "unused resources niq/neq (%d/%d)"
2203                          " ignored\n", vfres->niq, vfres->neq - ethqsets*2);
2204         }
2205         adapter->sge.max_ethqsets = ethqsets;
2206
2207         /*
2208          * Check for various parameter sanity issues.  Most checks simply
2209          * result in us using fewer resources than our provissioning but we
2210          * do need at least  one "port" with which to work ...
2211          */
2212         if (adapter->sge.max_ethqsets < adapter->params.nports) {
2213                 dev_warn(adapter->pdev_dev, "only using %d of %d available"
2214                          " virtual interfaces (too few Queue Sets)\n",
2215                          adapter->sge.max_ethqsets, adapter->params.nports);
2216                 adapter->params.nports = adapter->sge.max_ethqsets;
2217         }
2218         if (adapter->params.nports == 0) {
2219                 dev_err(adapter->pdev_dev, "no virtual interfaces configured/"
2220                         "usable!\n");
2221                 return -EINVAL;
2222         }
2223         return 0;
2224 }
2225
2226 static inline void init_rspq(struct sge_rspq *rspq, u8 timer_idx,
2227                              u8 pkt_cnt_idx, unsigned int size,
2228                              unsigned int iqe_size)
2229 {
2230         rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) |
2231                              (pkt_cnt_idx < SGE_NCOUNTERS ? QINTR_CNT_EN : 0));
2232         rspq->pktcnt_idx = (pkt_cnt_idx < SGE_NCOUNTERS
2233                             ? pkt_cnt_idx
2234                             : 0);
2235         rspq->iqe_len = iqe_size;
2236         rspq->size = size;
2237 }
2238
2239 /*
2240  * Perform default configuration of DMA queues depending on the number and
2241  * type of ports we found and the number of available CPUs.  Most settings can
2242  * be modified by the admin via ethtool and cxgbtool prior to the adapter
2243  * being brought up for the first time.
2244  */
2245 static void __devinit cfg_queues(struct adapter *adapter)
2246 {
2247         struct sge *s = &adapter->sge;
2248         int q10g, n10g, qidx, pidx, qs;
2249
2250         /*
2251          * We should not be called till we know how many Queue Sets we can
2252          * support.  In particular, this means that we need to know what kind
2253          * of interrupts we'll be using ...
2254          */
2255         BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0);
2256
2257         /*
2258          * Count the number of 10GbE Virtual Interfaces that we have.
2259          */
2260         n10g = 0;
2261         for_each_port(adapter, pidx)
2262                 n10g += is_10g_port(&adap2pinfo(adapter, pidx)->link_cfg);
2263
2264         /*
2265          * We default to 1 queue per non-10G port and up to # of cores queues
2266          * per 10G port.
2267          */
2268         if (n10g == 0)
2269                 q10g = 0;
2270         else {
2271                 int n1g = (adapter->params.nports - n10g);
2272                 q10g = (adapter->sge.max_ethqsets - n1g) / n10g;
2273                 if (q10g > num_online_cpus())
2274                         q10g = num_online_cpus();
2275         }
2276
2277         /*
2278          * Allocate the "Queue Sets" to the various Virtual Interfaces.
2279          * The layout will be established in setup_sge_queues() when the
2280          * adapter is brough up for the first time.
2281          */
2282         qidx = 0;
2283         for_each_port(adapter, pidx) {
2284                 struct port_info *pi = adap2pinfo(adapter, pidx);
2285
2286                 pi->first_qset = qidx;
2287                 pi->nqsets = is_10g_port(&pi->link_cfg) ? q10g : 1;
2288                 qidx += pi->nqsets;
2289         }
2290         s->ethqsets = qidx;
2291
2292         /*
2293          * Set up default Queue Set parameters ...  Start off with the
2294          * shortest interrupt holdoff timer.
2295          */
2296         for (qs = 0; qs < s->max_ethqsets; qs++) {
2297                 struct sge_eth_rxq *rxq = &s->ethrxq[qs];
2298                 struct sge_eth_txq *txq = &s->ethtxq[qs];
2299
2300                 init_rspq(&rxq->rspq, 0, 0, 1024, L1_CACHE_BYTES);
2301                 rxq->fl.size = 72;
2302                 txq->q.size = 1024;
2303         }
2304
2305         /*
2306          * The firmware event queue is used for link state changes and
2307          * notifications of TX DMA completions.
2308          */
2309         init_rspq(&s->fw_evtq, SGE_TIMER_RSTRT_CNTR, 0, 512,
2310                   L1_CACHE_BYTES);
2311
2312         /*
2313          * The forwarded interrupt queue is used when we're in MSI interrupt
2314          * mode.  In this mode all interrupts associated with RX queues will
2315          * be forwarded to a single queue which we'll associate with our MSI
2316          * interrupt vector.  The messages dropped in the forwarded interrupt
2317          * queue will indicate which ingress queue needs servicing ...  This
2318          * queue needs to be large enough to accommodate all of the ingress
2319          * queues which are forwarding their interrupt (+1 to prevent the PIDX
2320          * from equalling the CIDX if every ingress queue has an outstanding
2321          * interrupt).  The queue doesn't need to be any larger because no
2322          * ingress queue will ever have more than one outstanding interrupt at
2323          * any time ...
2324          */
2325         init_rspq(&s->intrq, SGE_TIMER_RSTRT_CNTR, 0, MSIX_ENTRIES + 1,
2326                   L1_CACHE_BYTES);
2327 }
2328
2329 /*
2330  * Reduce the number of Ethernet queues across all ports to at most n.
2331  * n provides at least one queue per port.
2332  */
2333 static void __devinit reduce_ethqs(struct adapter *adapter, int n)
2334 {
2335         int i;
2336         struct port_info *pi;
2337
2338         /*
2339          * While we have too many active Ether Queue Sets, interate across the
2340          * "ports" and reduce their individual Queue Set allocations.
2341          */
2342         BUG_ON(n < adapter->params.nports);
2343         while (n < adapter->sge.ethqsets)
2344                 for_each_port(adapter, i) {
2345                         pi = adap2pinfo(adapter, i);
2346                         if (pi->nqsets > 1) {
2347                                 pi->nqsets--;
2348                                 adapter->sge.ethqsets--;
2349                                 if (adapter->sge.ethqsets <= n)
2350                                         break;
2351                         }
2352                 }
2353
2354         /*
2355          * Reassign the starting Queue Sets for each of the "ports" ...
2356          */
2357         n = 0;
2358         for_each_port(adapter, i) {
2359                 pi = adap2pinfo(adapter, i);
2360                 pi->first_qset = n;
2361                 n += pi->nqsets;
2362         }
2363 }
2364
2365 /*
2366  * We need to grab enough MSI-X vectors to cover our interrupt needs.  Ideally
2367  * we get a separate MSI-X vector for every "Queue Set" plus any extras we
2368  * need.  Minimally we need one for every Virtual Interface plus those needed
2369  * for our "extras".  Note that this process may lower the maximum number of
2370  * allowed Queue Sets ...
2371  */
2372 static int __devinit enable_msix(struct adapter *adapter)
2373 {
2374         int i, err, want, need;
2375         struct msix_entry entries[MSIX_ENTRIES];
2376         struct sge *s = &adapter->sge;
2377
2378         for (i = 0; i < MSIX_ENTRIES; ++i)
2379                 entries[i].entry = i;
2380
2381         /*
2382          * We _want_ enough MSI-X interrupts to cover all of our "Queue Sets"
2383          * plus those needed for our "extras" (for example, the firmware
2384          * message queue).  We _need_ at least one "Queue Set" per Virtual
2385          * Interface plus those needed for our "extras".  So now we get to see
2386          * if the song is right ...
2387          */
2388         want = s->max_ethqsets + MSIX_EXTRAS;
2389         need = adapter->params.nports + MSIX_EXTRAS;
2390         while ((err = pci_enable_msix(adapter->pdev, entries, want)) >= need)
2391                 want = err;
2392
2393         if (err == 0) {
2394                 int nqsets = want - MSIX_EXTRAS;
2395                 if (nqsets < s->max_ethqsets) {
2396                         dev_warn(adapter->pdev_dev, "only enough MSI-X vectors"
2397                                  " for %d Queue Sets\n", nqsets);
2398                         s->max_ethqsets = nqsets;
2399                         if (nqsets < s->ethqsets)
2400                                 reduce_ethqs(adapter, nqsets);
2401                 }
2402                 for (i = 0; i < want; ++i)
2403                         adapter->msix_info[i].vec = entries[i].vector;
2404         } else if (err > 0) {
2405                 pci_disable_msix(adapter->pdev);
2406                 dev_info(adapter->pdev_dev, "only %d MSI-X vectors left,"
2407                          " not using MSI-X\n", err);
2408         }
2409         return err;
2410 }
2411
2412 #ifdef HAVE_NET_DEVICE_OPS
2413 static const struct net_device_ops cxgb4vf_netdev_ops   = {
2414         .ndo_open               = cxgb4vf_open,
2415         .ndo_stop               = cxgb4vf_stop,
2416         .ndo_start_xmit         = t4vf_eth_xmit,
2417         .ndo_get_stats          = cxgb4vf_get_stats,
2418         .ndo_set_rx_mode        = cxgb4vf_set_rxmode,
2419         .ndo_set_mac_address    = cxgb4vf_set_mac_addr,
2420         .ndo_select_queue       = cxgb4vf_select_queue,
2421         .ndo_validate_addr      = eth_validate_addr,
2422         .ndo_do_ioctl           = cxgb4vf_do_ioctl,
2423         .ndo_change_mtu         = cxgb4vf_change_mtu,
2424         .ndo_vlan_rx_register   = cxgb4vf_vlan_rx_register,
2425 #ifdef CONFIG_NET_POLL_CONTROLLER
2426         .ndo_poll_controller    = cxgb4vf_poll_controller,
2427 #endif
2428 };
2429 #endif
2430
2431 /*
2432  * "Probe" a device: initialize a device and construct all kernel and driver
2433  * state needed to manage the device.  This routine is called "init_one" in
2434  * the PF Driver ...
2435  */
2436 static int __devinit cxgb4vf_pci_probe(struct pci_dev *pdev,
2437                                        const struct pci_device_id *ent)
2438 {
2439         static int version_printed;
2440
2441         int pci_using_dac;
2442         int err, pidx;
2443         unsigned int pmask;
2444         struct adapter *adapter;
2445         struct port_info *pi;
2446         struct net_device *netdev;
2447
2448         /*
2449          * Vet our module parameters.
2450          */
2451         if (msi != MSI_MSIX && msi != MSI_MSI) {
2452                 dev_err(&pdev->dev, "bad module parameter msi=%d; must be %d"
2453                         " (MSI-X or MSI) or %d (MSI)\n", msi, MSI_MSIX,
2454                         MSI_MSI);
2455                 err = -EINVAL;
2456                 goto err_out;
2457         }
2458
2459         /*
2460          * Print our driver banner the first time we're called to initialize a
2461          * device.
2462          */
2463         if (version_printed == 0) {
2464                 printk(KERN_INFO "%s - version %s\n", DRV_DESC, DRV_VERSION);
2465                 version_printed = 1;
2466         }
2467
2468
2469         /*
2470          * Initialize generic PCI device state.
2471          */
2472         err = pci_enable_device(pdev);
2473         if (err) {
2474                 dev_err(&pdev->dev, "cannot enable PCI device\n");
2475                 return err;
2476         }
2477
2478         /*
2479          * Reserve PCI resources for the device.  If we can't get them some
2480          * other driver may have already claimed the device ...
2481          */
2482         err = pci_request_regions(pdev, KBUILD_MODNAME);
2483         if (err) {
2484                 dev_err(&pdev->dev, "cannot obtain PCI resources\n");
2485                 goto err_disable_device;
2486         }
2487
2488         /*
2489          * Set up our DMA mask: try for 64-bit address masking first and
2490          * fall back to 32-bit if we can't get 64 bits ...
2491          */
2492         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2493         if (err == 0) {
2494                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
2495                 if (err) {
2496                         dev_err(&pdev->dev, "unable to obtain 64-bit DMA for"
2497                                 " coherent allocations\n");
2498                         goto err_release_regions;
2499                 }
2500                 pci_using_dac = 1;
2501         } else {
2502                 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2503                 if (err != 0) {
2504                         dev_err(&pdev->dev, "no usable DMA configuration\n");
2505                         goto err_release_regions;
2506                 }
2507                 pci_using_dac = 0;
2508         }
2509
2510         /*
2511          * Enable bus mastering for the device ...
2512          */
2513         pci_set_master(pdev);
2514
2515         /*
2516          * Allocate our adapter data structure and attach it to the device.
2517          */
2518         adapter = kzalloc(sizeof(*adapter), GFP_KERNEL);
2519         if (!adapter) {
2520                 err = -ENOMEM;
2521                 goto err_release_regions;
2522         }
2523         pci_set_drvdata(pdev, adapter);
2524         adapter->pdev = pdev;
2525         adapter->pdev_dev = &pdev->dev;
2526
2527         /*
2528          * Initialize SMP data synchronization resources.
2529          */
2530         spin_lock_init(&adapter->stats_lock);
2531
2532         /*
2533          * Map our I/O registers in BAR0.
2534          */
2535         adapter->regs = pci_ioremap_bar(pdev, 0);
2536         if (!adapter->regs) {
2537                 dev_err(&pdev->dev, "cannot map device registers\n");
2538                 err = -ENOMEM;
2539                 goto err_free_adapter;
2540         }
2541
2542         /*
2543          * Initialize adapter level features.
2544          */
2545         adapter->name = pci_name(pdev);
2546         adapter->msg_enable = dflt_msg_enable;
2547         err = adap_init0(adapter);
2548         if (err)
2549                 goto err_unmap_bar;
2550
2551         /*
2552          * Allocate our "adapter ports" and stitch everything together.
2553          */
2554         pmask = adapter->params.vfres.pmask;
2555         for_each_port(adapter, pidx) {
2556                 int port_id, viid;
2557
2558                 /*
2559                  * We simplistically allocate our virtual interfaces
2560                  * sequentially across the port numbers to which we have
2561                  * access rights.  This should be configurable in some manner
2562                  * ...
2563                  */
2564                 if (pmask == 0)
2565                         break;
2566                 port_id = ffs(pmask) - 1;
2567                 pmask &= ~(1 << port_id);
2568                 viid = t4vf_alloc_vi(adapter, port_id);
2569                 if (viid < 0) {
2570                         dev_err(&pdev->dev, "cannot allocate VI for port %d:"
2571                                 " err=%d\n", port_id, viid);
2572                         err = viid;
2573                         goto err_free_dev;
2574                 }
2575
2576                 /*
2577                  * Allocate our network device and stitch things together.
2578                  */
2579                 netdev = alloc_etherdev_mq(sizeof(struct port_info),
2580                                            MAX_PORT_QSETS);
2581                 if (netdev == NULL) {
2582                         dev_err(&pdev->dev, "cannot allocate netdev for"
2583                                 " port %d\n", port_id);
2584                         t4vf_free_vi(adapter, viid);
2585                         err = -ENOMEM;
2586                         goto err_free_dev;
2587                 }
2588                 adapter->port[pidx] = netdev;
2589                 SET_NETDEV_DEV(netdev, &pdev->dev);
2590                 pi = netdev_priv(netdev);
2591                 pi->adapter = adapter;
2592                 pi->pidx = pidx;
2593                 pi->port_id = port_id;
2594                 pi->viid = viid;
2595
2596                 /*
2597                  * Initialize the starting state of our "port" and register
2598                  * it.
2599                  */
2600                 pi->xact_addr_filt = -1;
2601                 pi->rx_offload = RX_CSO;
2602                 netif_carrier_off(netdev);
2603                 netif_tx_stop_all_queues(netdev);
2604                 netdev->irq = pdev->irq;
2605
2606                 netdev->features = (NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
2607                                     NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
2608                                     NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX |
2609                                     NETIF_F_GRO);
2610                 if (pci_using_dac)
2611                         netdev->features |= NETIF_F_HIGHDMA;
2612                 netdev->vlan_features =
2613                         (netdev->features &
2614                          ~(NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX));
2615
2616 #ifdef HAVE_NET_DEVICE_OPS
2617                 netdev->netdev_ops = &cxgb4vf_netdev_ops;
2618 #else
2619                 netdev->vlan_rx_register = cxgb4vf_vlan_rx_register;
2620                 netdev->open = cxgb4vf_open;
2621                 netdev->stop = cxgb4vf_stop;
2622                 netdev->hard_start_xmit = t4vf_eth_xmit;
2623                 netdev->get_stats = cxgb4vf_get_stats;
2624                 netdev->set_rx_mode = cxgb4vf_set_rxmode;
2625                 netdev->do_ioctl = cxgb4vf_do_ioctl;
2626                 netdev->change_mtu = cxgb4vf_change_mtu;
2627                 netdev->set_mac_address = cxgb4vf_set_mac_addr;
2628                 netdev->select_queue = cxgb4vf_select_queue;
2629 #ifdef CONFIG_NET_POLL_CONTROLLER
2630                 netdev->poll_controller = cxgb4vf_poll_controller;
2631 #endif
2632 #endif
2633                 SET_ETHTOOL_OPS(netdev, &cxgb4vf_ethtool_ops);
2634
2635                 /*
2636                  * Initialize the hardware/software state for the port.
2637                  */
2638                 err = t4vf_port_init(adapter, pidx);
2639                 if (err) {
2640                         dev_err(&pdev->dev, "cannot initialize port %d\n",
2641                                 pidx);
2642                         goto err_free_dev;
2643                 }
2644         }
2645
2646         /*
2647          * The "card" is now ready to go.  If any errors occur during device
2648          * registration we do not fail the whole "card" but rather proceed
2649          * only with the ports we manage to register successfully.  However we
2650          * must register at least one net device.
2651          */
2652         for_each_port(adapter, pidx) {
2653                 netdev = adapter->port[pidx];
2654                 if (netdev == NULL)
2655                         continue;
2656
2657                 err = register_netdev(netdev);
2658                 if (err) {
2659                         dev_warn(&pdev->dev, "cannot register net device %s,"
2660                                  " skipping\n", netdev->name);
2661                         continue;
2662                 }
2663
2664                 set_bit(pidx, &adapter->registered_device_map);
2665         }
2666         if (adapter->registered_device_map == 0) {
2667                 dev_err(&pdev->dev, "could not register any net devices\n");
2668                 goto err_free_dev;
2669         }
2670
2671         /*
2672          * Set up our debugfs entries.
2673          */
2674         if (cxgb4vf_debugfs_root) {
2675                 adapter->debugfs_root =
2676                         debugfs_create_dir(pci_name(pdev),
2677                                            cxgb4vf_debugfs_root);
2678                 if (adapter->debugfs_root == NULL)
2679                         dev_warn(&pdev->dev, "could not create debugfs"
2680                                  " directory");
2681                 else
2682                         setup_debugfs(adapter);
2683         }
2684
2685         /*
2686          * See what interrupts we'll be using.  If we've been configured to
2687          * use MSI-X interrupts, try to enable them but fall back to using
2688          * MSI interrupts if we can't enable MSI-X interrupts.  If we can't
2689          * get MSI interrupts we bail with the error.
2690          */
2691         if (msi == MSI_MSIX && enable_msix(adapter) == 0)
2692                 adapter->flags |= USING_MSIX;
2693         else {
2694                 err = pci_enable_msi(pdev);
2695                 if (err) {
2696                         dev_err(&pdev->dev, "Unable to allocate %s interrupts;"
2697                                 " err=%d\n",
2698                                 msi == MSI_MSIX ? "MSI-X or MSI" : "MSI", err);
2699                         goto err_free_debugfs;
2700                 }
2701                 adapter->flags |= USING_MSI;
2702         }
2703
2704         /*
2705          * Now that we know how many "ports" we have and what their types are,
2706          * and how many Queue Sets we can support, we can configure our queue
2707          * resources.
2708          */
2709         cfg_queues(adapter);
2710
2711         /*
2712          * Print a short notice on the existance and configuration of the new
2713          * VF network device ...
2714          */
2715         for_each_port(adapter, pidx) {
2716                 dev_info(adapter->pdev_dev, "%s: Chelsio VF NIC PCIe %s\n",
2717                          adapter->port[pidx]->name,
2718                          (adapter->flags & USING_MSIX) ? "MSI-X" :
2719                          (adapter->flags & USING_MSI)  ? "MSI" : "");
2720         }
2721
2722         /*
2723          * Return success!
2724          */
2725         return 0;
2726
2727         /*
2728          * Error recovery and exit code.  Unwind state that's been created
2729          * so far and return the error.
2730          */
2731
2732 err_free_debugfs:
2733         if (adapter->debugfs_root) {
2734                 cleanup_debugfs(adapter);
2735                 debugfs_remove_recursive(adapter->debugfs_root);
2736         }
2737
2738 err_free_dev:
2739         for_each_port(adapter, pidx) {
2740                 netdev = adapter->port[pidx];
2741                 if (netdev == NULL)
2742                         continue;
2743                 pi = netdev_priv(netdev);
2744                 t4vf_free_vi(adapter, pi->viid);
2745                 if (test_bit(pidx, &adapter->registered_device_map))
2746                         unregister_netdev(netdev);
2747                 free_netdev(netdev);
2748         }
2749
2750 err_unmap_bar:
2751         iounmap(adapter->regs);
2752
2753 err_free_adapter:
2754         kfree(adapter);
2755         pci_set_drvdata(pdev, NULL);
2756
2757 err_release_regions:
2758         pci_release_regions(pdev);
2759         pci_set_drvdata(pdev, NULL);
2760         pci_clear_master(pdev);
2761
2762 err_disable_device:
2763         pci_disable_device(pdev);
2764
2765 err_out:
2766         return err;
2767 }
2768
2769 /*
2770  * "Remove" a device: tear down all kernel and driver state created in the
2771  * "probe" routine and quiesce the device (disable interrupts, etc.).  (Note
2772  * that this is called "remove_one" in the PF Driver.)
2773  */
2774 static void __devexit cxgb4vf_pci_remove(struct pci_dev *pdev)
2775 {
2776         struct adapter *adapter = pci_get_drvdata(pdev);
2777
2778         /*
2779          * Tear down driver state associated with device.
2780          */
2781         if (adapter) {
2782                 int pidx;
2783
2784                 /*
2785                  * Stop all of our activity.  Unregister network port,
2786                  * disable interrupts, etc.
2787                  */
2788                 for_each_port(adapter, pidx)
2789                         if (test_bit(pidx, &adapter->registered_device_map))
2790                                 unregister_netdev(adapter->port[pidx]);
2791                 t4vf_sge_stop(adapter);
2792                 if (adapter->flags & USING_MSIX) {
2793                         pci_disable_msix(adapter->pdev);
2794                         adapter->flags &= ~USING_MSIX;
2795                 } else if (adapter->flags & USING_MSI) {
2796                         pci_disable_msi(adapter->pdev);
2797                         adapter->flags &= ~USING_MSI;
2798                 }
2799
2800                 /*
2801                  * Tear down our debugfs entries.
2802                  */
2803                 if (adapter->debugfs_root) {
2804                         cleanup_debugfs(adapter);
2805                         debugfs_remove_recursive(adapter->debugfs_root);
2806                 }
2807
2808                 /*
2809                  * Free all of the various resources which we've acquired ...
2810                  */
2811                 t4vf_free_sge_resources(adapter);
2812                 for_each_port(adapter, pidx) {
2813                         struct net_device *netdev = adapter->port[pidx];
2814                         struct port_info *pi;
2815
2816                         if (netdev == NULL)
2817                                 continue;
2818
2819                         pi = netdev_priv(netdev);
2820                         t4vf_free_vi(adapter, pi->viid);
2821                         free_netdev(netdev);
2822                 }
2823                 iounmap(adapter->regs);
2824                 kfree(adapter);
2825                 pci_set_drvdata(pdev, NULL);
2826         }
2827
2828         /*
2829          * Disable the device and release its PCI resources.
2830          */
2831         pci_disable_device(pdev);
2832         pci_clear_master(pdev);
2833         pci_release_regions(pdev);
2834 }
2835
2836 /*
2837  * PCI Device registration data structures.
2838  */
2839 #define CH_DEVICE(devid, idx) \
2840         { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
2841
2842 static struct pci_device_id cxgb4vf_pci_tbl[] = {
2843         CH_DEVICE(0xb000, 0),   /* PE10K FPGA */
2844         CH_DEVICE(0x4800, 0),   /* T440-dbg */
2845         CH_DEVICE(0x4801, 0),   /* T420-cr */
2846         CH_DEVICE(0x4802, 0),   /* T422-cr */
2847         { 0, }
2848 };
2849
2850 MODULE_DESCRIPTION(DRV_DESC);
2851 MODULE_AUTHOR("Chelsio Communications");
2852 MODULE_LICENSE("Dual BSD/GPL");
2853 MODULE_VERSION(DRV_VERSION);
2854 MODULE_DEVICE_TABLE(pci, cxgb4vf_pci_tbl);
2855
2856 static struct pci_driver cxgb4vf_driver = {
2857         .name           = KBUILD_MODNAME,
2858         .id_table       = cxgb4vf_pci_tbl,
2859         .probe          = cxgb4vf_pci_probe,
2860         .remove         = __devexit_p(cxgb4vf_pci_remove),
2861 };
2862
2863 /*
2864  * Initialize global driver state.
2865  */
2866 static int __init cxgb4vf_module_init(void)
2867 {
2868         int ret;
2869
2870         /* Debugfs support is optional, just warn if this fails */
2871         cxgb4vf_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
2872         if (!cxgb4vf_debugfs_root)
2873                 printk(KERN_WARNING KBUILD_MODNAME ": could not create"
2874                        " debugfs entry, continuing\n");
2875
2876         ret = pci_register_driver(&cxgb4vf_driver);
2877         if (ret < 0)
2878                 debugfs_remove(cxgb4vf_debugfs_root);
2879         return ret;
2880 }
2881
2882 /*
2883  * Tear down global driver state.
2884  */
2885 static void __exit cxgb4vf_module_exit(void)
2886 {
2887         pci_unregister_driver(&cxgb4vf_driver);
2888         debugfs_remove(cxgb4vf_debugfs_root);
2889 }
2890
2891 module_init(cxgb4vf_module_init);
2892 module_exit(cxgb4vf_module_exit);