drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c

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