Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us