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