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