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