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