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